@docyrus/generative-ui-core 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1222 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DASHBOARD_CUSTOM_RULES: () => DASHBOARD_CUSTOM_RULES,
+  DATA_GRID_CUSTOM_RULES: () => DATA_GRID_CUSTOM_RULES,
+  EMAIL_CUSTOM_RULES: () => EMAIL_CUSTOM_RULES,
+  FORM_CUSTOM_RULES: () => FORM_CUSTOM_RULES,
+  IMAGE_CUSTOM_RULES: () => IMAGE_CUSTOM_RULES,
+  PDF_CUSTOM_RULES: () => PDF_CUSTOM_RULES,
+  ROOT_ELEMENT_TYPES: () => ROOT_ELEMENT_TYPES,
+  SUPPORTED_MODES: () => SUPPORTED_MODES,
+  WIDGET_CUSTOM_RULES: () => WIDGET_CUSTOM_RULES,
+  compileDashboardSpec: () => compileDashboardSpec,
+  compileDataGridSpec: () => compileDataGridSpec,
+  compileFormSpec: () => compileFormSpec,
+  compileWidgetSpec: () => compileWidgetSpec,
+  createDashboardAdapterSpec: () => createDashboardAdapterSpec,
+  createDataGridAdapterSpec: () => createDataGridAdapterSpec,
+  createFormAdapterSpec: () => createFormAdapterSpec,
+  createWidgetAdapterSpec: () => createWidgetAdapterSpec,
+  dashboardCatalog: () => dashboardCatalog,
+  dashboardSchema: () => dashboardSchema,
+  dashboardStandardComponentDefinitions: () => dashboardStandardComponentDefinitions,
+  dataGridCatalog: () => dataGridCatalog,
+  dataGridSchema: () => dataGridSchema,
+  dataGridStandardComponentDefinitions: () => dataGridStandardComponentDefinitions,
+  emailCatalog: () => emailCatalog,
+  formCatalog: () => formCatalog,
+  formSchema: () => formSchema,
+  formStandardComponentDefinitions: () => formStandardComponentDefinitions,
+  getCatalogForMode: () => getCatalogForMode,
+  imageCatalog: () => imageCatalog,
+  pdfCatalog: () => pdfCatalog,
+  widgetCatalog: () => widgetCatalog,
+  widgetSchema: () => widgetSchema,
+  widgetStandardComponentDefinitions: () => widgetStandardComponentDefinitions
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mode-catalogs.ts
+var import_core = require("@json-render/core");
+var import_v4 = require("zod/v4");
+var DEFAULT_GRID_BREAKPOINTS = [
+  "lg",
+  "md",
+  "sm",
+  "xs",
+  "xxs"
+];
+function createReactModeSchema(defaultRules) {
+  return (0, import_core.defineSchema)(
+    (s) => ({
+      spec: s.object({
+        root: s.string(),
+        elements: s.record(
+          s.object({
+            type: s.ref("catalog.components"),
+            props: s.propsOf("catalog.components"),
+            children: s.array(s.string()),
+            visible: s.any()
+          })
+        )
+      }),
+      catalog: s.object({
+        components: s.map({
+          props: s.zod(),
+          slots: s.array(s.string()),
+          description: s.string(),
+          example: s.any()
+        }),
+        actions: s.map({
+          params: s.zod(),
+          description: s.string()
+        })
+      })
+    }),
+    { defaultRules }
+  );
+}
+var smartCanvasGridItemSchema = import_v4.z.object({
+  i: import_v4.z.string().optional(),
+  x: import_v4.z.number(),
+  y: import_v4.z.number(),
+  w: import_v4.z.number(),
+  h: import_v4.z.number(),
+  minW: import_v4.z.number().optional(),
+  maxW: import_v4.z.number().optional(),
+  minH: import_v4.z.number().optional(),
+  maxH: import_v4.z.number().optional(),
+  static: import_v4.z.boolean().optional(),
+  isDraggable: import_v4.z.boolean().optional(),
+  isResizable: import_v4.z.boolean().optional()
+});
+var smartCanvasFlowNodeLayoutSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  x: import_v4.z.number(),
+  y: import_v4.z.number(),
+  width: import_v4.z.number().optional(),
+  height: import_v4.z.number().optional()
+});
+var smartCanvasFlowViewportSchema = import_v4.z.object({
+  x: import_v4.z.number(),
+  y: import_v4.z.number(),
+  zoom: import_v4.z.number()
+});
+var dashboardWidgetLayoutSchema = import_v4.z.object({
+  grid: import_v4.z.record(import_v4.z.string(), smartCanvasGridItemSchema).optional(),
+  flow: smartCanvasFlowNodeLayoutSchema.optional(),
+  stackOrder: import_v4.z.number().int().optional()
+});
+var smartCanvasSeriesConfigSchema = import_v4.z.object({
+  field: import_v4.z.string(),
+  label: import_v4.z.string().optional(),
+  color: import_v4.z.string().optional()
+});
+var smartCanvasCartesianChartConfigSchema = import_v4.z.object({
+  xField: import_v4.z.string(),
+  series: import_v4.z.array(smartCanvasSeriesConfigSchema).min(1),
+  aspectRatio: import_v4.z.string().optional(),
+  showGrid: import_v4.z.boolean().optional(),
+  showTooltip: import_v4.z.boolean().optional(),
+  stacked: import_v4.z.boolean().optional(),
+  orientation: import_v4.z.enum(["vertical", "horizontal"]).optional()
+});
+var smartCanvasCategoryChartConfigSchema = import_v4.z.object({
+  labelField: import_v4.z.string(),
+  valueField: import_v4.z.string(),
+  colorField: import_v4.z.string().optional(),
+  maxValueField: import_v4.z.string().optional(),
+  aspectRatio: import_v4.z.string().optional(),
+  innerRadius: import_v4.z.number().optional(),
+  orientation: import_v4.z.enum(["vertical", "horizontal"]).optional()
+});
+var smartCanvasRadarMetricConfigSchema = import_v4.z.object({
+  key: import_v4.z.string(),
+  label: import_v4.z.string().optional()
+});
+var smartCanvasRadarChartConfigSchema = import_v4.z.object({
+  labelField: import_v4.z.string(),
+  metrics: import_v4.z.array(smartCanvasRadarMetricConfigSchema).min(1),
+  colorField: import_v4.z.string().optional()
+});
+var smartCanvasSankeyChartConfigSchema = import_v4.z.object({
+  sourceField: import_v4.z.string(),
+  targetField: import_v4.z.string(),
+  valueField: import_v4.z.string()
+});
+var smartCanvasChoroplethFeatureSchema = import_v4.z.object({
+  type: import_v4.z.literal("Feature"),
+  geometry: import_v4.z.any(),
+  properties: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).nullable().optional(),
+  id: import_v4.z.union([import_v4.z.string(), import_v4.z.number()]).optional()
+});
+var smartCanvasChoroplethFeatureCollectionSchema = import_v4.z.object({
+  type: import_v4.z.literal("FeatureCollection"),
+  features: import_v4.z.array(smartCanvasChoroplethFeatureSchema)
+});
+var smartCanvasChoroplethChartConfigSchema = import_v4.z.object({
+  featureIdField: import_v4.z.string(),
+  valueField: import_v4.z.string(),
+  featureCollection: smartCanvasChoroplethFeatureCollectionSchema
+});
+var smartCanvasStatsFormatConfigSchema = import_v4.z.object({
+  locale: import_v4.z.string().optional(),
+  style: import_v4.z.enum(["number", "currency", "percent"]).optional(),
+  currency: import_v4.z.string().optional(),
+  currencyDisplay: import_v4.z.enum([
+    "symbol",
+    "code",
+    "name",
+    "narrowSymbol"
+  ]).optional(),
+  notation: import_v4.z.enum([
+    "standard",
+    "scientific",
+    "engineering",
+    "compact"
+  ]).optional(),
+  minimumFractionDigits: import_v4.z.number().optional(),
+  maximumFractionDigits: import_v4.z.number().optional(),
+  signDisplay: import_v4.z.enum([
+    "auto",
+    "always",
+    "exceptZero",
+    "negative",
+    "never"
+  ]).optional(),
+  percentScale: import_v4.z.enum(["whole", "fraction"]).optional()
+});
+var smartCanvasStatsItemConfigSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  title: import_v4.z.string(),
+  valueField: import_v4.z.string(),
+  eyebrow: import_v4.z.string().optional(),
+  subtitle: import_v4.z.string().optional(),
+  icon: import_v4.z.string().optional(),
+  color: import_v4.z.string().optional(),
+  unitLabel: import_v4.z.string().optional(),
+  format: smartCanvasStatsFormatConfigSchema.optional()
+});
+var smartCanvasStatsLayoutSchema = import_v4.z.discriminatedUnion("type", [
+  import_v4.z.object({
+    type: import_v4.z.literal("grid"),
+    columns: import_v4.z.number(),
+    gap: import_v4.z.union([import_v4.z.number(), import_v4.z.string()]).optional(),
+    maxCardWidth: import_v4.z.union([import_v4.z.number(), import_v4.z.string()]).optional()
+  }),
+  import_v4.z.object({
+    type: import_v4.z.literal("flex"),
+    cardWidth: import_v4.z.union([import_v4.z.number(), import_v4.z.string()]),
+    behavior: import_v4.z.enum(["wrap", "scroll"]),
+    gap: import_v4.z.union([import_v4.z.number(), import_v4.z.string()]).optional()
+  }),
+  import_v4.z.object({
+    type: import_v4.z.literal("tabs"),
+    defaultTabId: import_v4.z.string().optional()
+  })
+]);
+var smartCanvasStatsConfigSchema = import_v4.z.object({
+  items: import_v4.z.array(smartCanvasStatsItemConfigSchema).min(1),
+  layout: smartCanvasStatsLayoutSchema
+});
+var smartCanvasDataGridColumnConfigSchema = import_v4.z.object({
+  key: import_v4.z.string(),
+  header: import_v4.z.string().optional()
+});
+var smartCanvasDataGridConfigSchema = import_v4.z.object({
+  columns: import_v4.z.array(smartCanvasDataGridColumnConfigSchema).optional(),
+  rowHeight: import_v4.z.enum([
+    "short",
+    "medium",
+    "tall",
+    "extra-tall"
+  ]).optional(),
+  displayMode: import_v4.z.enum(["table", "gallery"]).optional(),
+  enableSearch: import_v4.z.boolean().optional()
+});
+var widgetBasePropsSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  title: import_v4.z.string(),
+  description: import_v4.z.string().optional(),
+  wrapInAwesomeCard: import_v4.z.boolean(),
+  query: import_v4.z.record(import_v4.z.string(), import_v4.z.any()),
+  locked: import_v4.z.boolean().optional(),
+  hidden: import_v4.z.boolean().optional(),
+  dashboardLayout: dashboardWidgetLayoutSchema.optional()
+});
+var dashboardSurfacePropsSchema = import_v4.z.object({
+  mode: import_v4.z.enum(["infinite-grid", "free-canvas", "stacked-cards"]).optional(),
+  selectedWidgetId: import_v4.z.string().nullable().optional(),
+  stackActiveId: import_v4.z.string().nullable().optional(),
+  flowViewport: smartCanvasFlowViewportSchema.nullable().optional()
+});
+var widgetSurfacePropsSchema = import_v4.z.object({});
+var formOptionSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  name: import_v4.z.string(),
+  color: import_v4.z.string().optional(),
+  icon: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional()
+});
+var formFieldBasePropsSchema = import_v4.z.object({
+  id: import_v4.z.string(),
+  name: import_v4.z.string(),
+  slug: import_v4.z.string(),
+  description: import_v4.z.string().optional(),
+  placeholder: import_v4.z.string().optional(),
+  helperText: import_v4.z.string().optional(),
+  required: import_v4.z.boolean().optional(),
+  readOnly: import_v4.z.boolean().optional(),
+  defaultValue: import_v4.z.any().optional(),
+  validations: import_v4.z.array(import_v4.z.string()).nullable().optional()
+});
+var choiceFieldPropsSchema = formFieldBasePropsSchema.extend({
+  options: import_v4.z.array(formOptionSchema).min(1)
+});
+var formSurfacePropsSchema = import_v4.z.object({
+  title: import_v4.z.string().optional(),
+  description: import_v4.z.string().optional(),
+  submitLabel: import_v4.z.string().optional(),
+  initialValues: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional()
+});
+function createWidgetDefinition(configSchema, description, example) {
+  return {
+    props: widgetBasePropsSchema.extend({ config: configSchema }),
+    slots: [],
+    description,
+    example
+  };
+}
+function createFieldDefinition(props, description, example) {
+  return {
+    props,
+    slots: [],
+    description,
+    example
+  };
+}
+var WIDGET_COMPONENT_KIND_BY_NAME = {
+  LineChartWidget: "line-chart",
+  LiveLineChartWidget: "live-line-chart",
+  AreaChartWidget: "area-chart",
+  BarChartWidget: "bar-chart",
+  FunnelChartWidget: "funnel-chart",
+  RingChartWidget: "ring-chart",
+  PieChartWidget: "pie-chart",
+  RadarChartWidget: "radar-chart",
+  SankeyChartWidget: "sankey-chart",
+  ChoroplethChartWidget: "choropleth-chart",
+  AwesomeStatsWidget: "awesome-stats",
+  DataGridWidget: "data-grid"
+};
+var FIELD_COMPONENT_TYPE_BY_NAME = {
+  TextField: "field-text",
+  TextareaField: "field-textarea",
+  EmailField: "field-email",
+  NumberField: "field-number",
+  SelectField: "field-select",
+  RadioGroupField: "field-radioGroup",
+  CheckboxField: "field-checkbox",
+  SwitchField: "field-switch",
+  DateField: "field-date",
+  DateTimeField: "field-dateTime",
+  TimeField: "field-time",
+  DateRangeField: "field-dateRange"
+};
+var sharedWidgetStandardComponentDefinitions = {
+  LineChartWidget: createWidgetDefinition(
+    smartCanvasCartesianChartConfigSchema,
+    "A single line chart widget that plots one or more series against an x-axis field.",
+    {
+      id: "widget-revenue-trend",
+      title: "Revenue Trend",
+      wrapInAwesomeCard: true,
+      query: { columns: ["date", "revenue"] },
+      config: {
+        xField: "date",
+        series: [{ field: "revenue", label: "Revenue", color: "var(--chart-line-primary)" }],
+        showGrid: true,
+        showTooltip: true
+      },
+      dashboardLayout: {
+        grid: {
+          lg: {
+            x: 0,
+            y: 0,
+            w: 6,
+            h: 4
+          }
+        }
+      }
+    }
+  ),
+  LiveLineChartWidget: createWidgetDefinition(
+    smartCanvasCartesianChartConfigSchema,
+    "A line chart widget intended for live or near-real-time metrics.",
+    {
+      id: "widget-live-latency",
+      title: "Live Latency",
+      wrapInAwesomeCard: true,
+      query: { columns: ["timestamp", "latency_ms"] },
+      config: {
+        xField: "timestamp",
+        series: [{ field: "latency_ms", label: "Latency (ms)" }]
+      }
+    }
+  ),
+  AreaChartWidget: createWidgetDefinition(
+    smartCanvasCartesianChartConfigSchema,
+    "A filled trend chart widget for time-series or cumulative comparisons.",
+    {
+      id: "widget-signups-area",
+      title: "Weekly Signups",
+      wrapInAwesomeCard: true,
+      query: { columns: ["week", "signups"] },
+      config: {
+        xField: "week",
+        series: [{ field: "signups", label: "Signups" }],
+        showGrid: true
+      }
+    }
+  ),
+  BarChartWidget: createWidgetDefinition(
+    smartCanvasCartesianChartConfigSchema,
+    "A grouped or stacked bar chart widget for categorical comparisons.",
+    {
+      id: "widget-pipeline-bars",
+      title: "Pipeline by Rep",
+      wrapInAwesomeCard: true,
+      query: { columns: ["rep", "pipeline_value"] },
+      config: {
+        xField: "rep",
+        series: [{ field: "pipeline_value", label: "Pipeline Value" }],
+        orientation: "vertical"
+      }
+    }
+  ),
+  FunnelChartWidget: createWidgetDefinition(
+    smartCanvasCategoryChartConfigSchema,
+    "A funnel widget for stage conversion or sequential drop-off analysis.",
+    {
+      id: "widget-support-funnel",
+      title: "Support Funnel",
+      wrapInAwesomeCard: true,
+      query: { columns: ["stage", "count"] },
+      config: {
+        labelField: "stage",
+        valueField: "count"
+      }
+    }
+  ),
+  RingChartWidget: createWidgetDefinition(
+    smartCanvasCategoryChartConfigSchema,
+    "A ring widget for progress-style categorical metrics.",
+    {
+      id: "widget-goal-rings",
+      title: "Quota Progress",
+      wrapInAwesomeCard: true,
+      query: { columns: ["team", "value", "maxValue"] },
+      config: {
+        labelField: "team",
+        valueField: "value",
+        maxValueField: "maxValue"
+      }
+    }
+  ),
+  PieChartWidget: createWidgetDefinition(
+    smartCanvasCategoryChartConfigSchema,
+    "A pie widget for showing distribution across categories.",
+    {
+      id: "widget-channel-mix",
+      title: "Channel Mix",
+      wrapInAwesomeCard: true,
+      query: { columns: ["channel", "tickets"] },
+      config: {
+        labelField: "channel",
+        valueField: "tickets",
+        innerRadius: 72
+      }
+    }
+  ),
+  RadarChartWidget: createWidgetDefinition(
+    smartCanvasRadarChartConfigSchema,
+    "A radar widget for comparing multiple metrics for one or more entities.",
+    {
+      id: "widget-team-radar",
+      title: "Team Profile",
+      wrapInAwesomeCard: true,
+      query: { columns: [
+        "team",
+        "quality",
+        "speed",
+        "scale"
+      ] },
+      config: {
+        labelField: "team",
+        metrics: [{ key: "quality", label: "Quality" }, { key: "speed", label: "Speed" }, { key: "scale", label: "Scale" }]
+      }
+    }
+  ),
+  SankeyChartWidget: createWidgetDefinition(
+    smartCanvasSankeyChartConfigSchema,
+    "A sankey widget for visualizing flow between source and target nodes.",
+    {
+      id: "widget-journey-sankey",
+      title: "Journey Flow",
+      wrapInAwesomeCard: true,
+      query: { columns: ["source", "target", "count"] },
+      config: {
+        sourceField: "source",
+        targetField: "target",
+        valueField: "count"
+      }
+    }
+  ),
+  ChoroplethChartWidget: createWidgetDefinition(
+    smartCanvasChoroplethChartConfigSchema,
+    "A choropleth widget that shades geographic features by a numeric field.",
+    {
+      id: "widget-global-coverage",
+      title: "Global Coverage",
+      wrapInAwesomeCard: true,
+      query: { columns: ["country_code", "coverage"] },
+      config: {
+        featureIdField: "country_code",
+        valueField: "coverage",
+        featureCollection: {
+          type: "FeatureCollection",
+          features: []
+        }
+      }
+    }
+  ),
+  AwesomeStatsWidget: createWidgetDefinition(
+    smartCanvasStatsConfigSchema,
+    "A stats card widget that presents one or more highlight metrics.",
+    {
+      id: "widget-top-metrics",
+      title: "Top Metrics",
+      wrapInAwesomeCard: true,
+      query: { columns: ["revenue", "conversion_rate"] },
+      config: {
+        items: [{ id: "revenue", title: "Revenue", valueField: "revenue" }, { id: "conversion", title: "Conversion", valueField: "conversion_rate" }],
+        layout: { type: "grid", columns: 2, gap: 16 }
+      }
+    }
+  ),
+  DataGridWidget: createWidgetDefinition(
+    smartCanvasDataGridConfigSchema,
+    "A read-only data grid widget for tabular or gallery-style datasets.",
+    {
+      id: "widget-open-deals",
+      title: "Open Deals",
+      wrapInAwesomeCard: false,
+      query: { columns: ["deal_name", "owner", "amount"] },
+      config: {
+        columns: [{ key: "deal_name", header: "Deal" }, { key: "owner", header: "Owner" }, { key: "amount", header: "Amount" }],
+        displayMode: "table",
+        rowHeight: "medium",
+        enableSearch: true
+      }
+    }
+  )
+};
+var dashboardStandardComponentDefinitions = {
+  DashboardSurface: {
+    props: dashboardSurfacePropsSchema,
+    slots: ["default"],
+    description: "Root dashboard surface. Use it as the root element and place widget components directly as children.",
+    example: {
+      mode: "infinite-grid",
+      selectedWidgetId: "widget-revenue-trend",
+      flowViewport: { x: 0, y: 0, zoom: 1 }
+    }
+  },
+  ...sharedWidgetStandardComponentDefinitions
+};
+var widgetStandardComponentDefinitions = {
+  WidgetSurface: {
+    props: widgetSurfacePropsSchema,
+    slots: ["default"],
+    description: "Root widget surface. Use it as the root element and place exactly one widget component as its child.",
+    example: {}
+  },
+  ...sharedWidgetStandardComponentDefinitions
+};
+var dataGridStandardComponentDefinitions = {
+  WidgetSurface: {
+    props: widgetSurfacePropsSchema,
+    slots: ["default"],
+    description: "Root data-grid surface. Use it as the root element and place exactly one DataGridWidget child.",
+    example: {}
+  },
+  DataGridWidget: sharedWidgetStandardComponentDefinitions.DataGridWidget
+};
+var formStandardComponentDefinitions = {
+  FormSurface: {
+    props: formSurfacePropsSchema,
+    slots: ["default"],
+    description: "Root form surface. Use it as the root element and place generated field components directly as children.",
+    example: {
+      title: "Lead Capture",
+      description: "Collect the details needed to qualify a new inbound lead.",
+      submitLabel: "Save lead",
+      initialValues: { region: "emea" }
+    }
+  },
+  TextField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Single-line text input field.",
+    {
+      id: "first_name",
+      name: "First name",
+      slug: "firstName",
+      placeholder: "Jane"
+    }
+  ),
+  TextareaField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Multi-line text area field.",
+    {
+      id: "summary",
+      name: "Summary",
+      slug: "summary",
+      helperText: "Add extra context for the team."
+    }
+  ),
+  EmailField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Email address input field.",
+    {
+      id: "email",
+      name: "Email",
+      slug: "email",
+      placeholder: "jane@example.com"
+    }
+  ),
+  NumberField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Numeric input field.",
+    {
+      id: "seats",
+      name: "Seats",
+      slug: "seats",
+      defaultValue: 25
+    }
+  ),
+  SelectField: createFieldDefinition(
+    choiceFieldPropsSchema,
+    "Select dropdown field with predefined options.",
+    {
+      id: "segment",
+      name: "Segment",
+      slug: "segment",
+      options: [{ id: "enterprise", name: "Enterprise" }, { id: "mid-market", name: "Mid-market" }]
+    }
+  ),
+  RadioGroupField: createFieldDefinition(
+    choiceFieldPropsSchema,
+    "Radio group field with mutually exclusive options.",
+    {
+      id: "priority",
+      name: "Priority",
+      slug: "priority",
+      options: [{ id: "high", name: "High" }, { id: "medium", name: "Medium" }]
+    }
+  ),
+  CheckboxField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Boolean checkbox field.",
+    {
+      id: "accept_terms",
+      name: "Accept terms",
+      slug: "acceptTerms",
+      required: true
+    }
+  ),
+  SwitchField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Boolean switch field.",
+    {
+      id: "notify_team",
+      name: "Notify team",
+      slug: "notifyTeam",
+      defaultValue: true
+    }
+  ),
+  DateField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Date picker field.",
+    { id: "start_date", name: "Start date", slug: "startDate" }
+  ),
+  DateTimeField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Date and time picker field.",
+    { id: "demo_slot", name: "Demo slot", slug: "demoSlot" }
+  ),
+  TimeField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Time-only picker field.",
+    { id: "meeting_time", name: "Meeting time", slug: "meetingTime" }
+  ),
+  DateRangeField: createFieldDefinition(
+    formFieldBasePropsSchema,
+    "Date range picker field.",
+    { id: "campaign_window", name: "Campaign window", slug: "campaignWindow" }
+  )
+};
+var dashboardSchema = createReactModeSchema([
+  "The root element MUST be DashboardSurface.",
+  "DashboardSurface children MUST be widget components only.",
+  `Supported dashboard widget components: ${Object.keys(WIDGET_COMPONENT_KIND_BY_NAME).join(", ")}.`,
+  "Use DashboardSurface props for mode selection and viewport metadata. Use widget dashboardLayout props for grid, flow, and stack placement metadata.",
+  "Widget components are shared with widget mode. Do not wrap them in another surface component.",
+  "CRITICAL INTEGRITY CHECK: Every child element referenced by DashboardSurface MUST exist in the flat elements map."
+]);
+var widgetSchema = createReactModeSchema([
+  "The root element MUST be WidgetSurface.",
+  "WidgetSurface MUST contain exactly one shared widget component child.",
+  `Supported widget components: ${Object.keys(WIDGET_COMPONENT_KIND_BY_NAME).join(", ")}.`,
+  "Do not use DashboardSurface in widget mode.",
+  "CRITICAL INTEGRITY CHECK: The widget child referenced by WidgetSurface MUST exist in the flat elements map."
+]);
+var dataGridSchema = createReactModeSchema([
+  "The root element MUST be WidgetSurface.",
+  "WidgetSurface MUST contain exactly one DataGridWidget child.",
+  "Supported component types: WidgetSurface and DataGridWidget.",
+  "Do not use chart widgets in data-grid mode.",
+  "CRITICAL INTEGRITY CHECK: The DataGridWidget child referenced by WidgetSurface MUST exist in the flat elements map."
+]);
+var formSchema = createReactModeSchema([
+  "The root element MUST be FormSurface.",
+  "FormSurface children MUST be field components only.",
+  `Supported field components: ${Object.keys(FIELD_COMPONENT_TYPE_BY_NAME).join(", ")}.`,
+  "Keep form-level title, description, submitLabel, and initialValues on FormSurface props.",
+  "Use options only for select-style fields such as SelectField and RadioGroupField.",
+  "CRITICAL INTEGRITY CHECK: Every child element referenced by FormSurface MUST exist in the flat elements map."
+]);
+var dashboardCatalog = (0, import_core.defineCatalog)(dashboardSchema, {
+  components: dashboardStandardComponentDefinitions,
+  actions: {}
+});
+var widgetCatalog = (0, import_core.defineCatalog)(widgetSchema, {
+  components: widgetStandardComponentDefinitions,
+  actions: {}
+});
+var dataGridCatalog = (0, import_core.defineCatalog)(dataGridSchema, {
+  components: dataGridStandardComponentDefinitions,
+  actions: {}
+});
+var formCatalog = (0, import_core.defineCatalog)(formSchema, {
+  components: formStandardComponentDefinitions,
+  actions: {}
+});
+function normalizeWidgetGridLayouts(widgetId, layouts) {
+  if (!layouts) {
+    return {};
+  }
+  return Object.entries(layouts).reduce((accumulator, [breakpoint, layout]) => {
+    if (!layout) {
+      return accumulator;
+    }
+    accumulator[breakpoint] = {
+      ...layout,
+      i: layout.i ?? widgetId
+    };
+    return accumulator;
+  }, {});
+}
+function compileDashboardValue(props, nodes) {
+  if (nodes.length === 0) {
+    throw new Error("DashboardSurface requires at least one widget child.");
+  }
+  const widgets = nodes.map(({ widget }) => widget);
+  const defaultSelectedId = widgets.find((widget) => !widget.hidden)?.id ?? widgets[0]?.id ?? null;
+  const selectedWidgetId = props.selectedWidgetId ?? defaultSelectedId;
+  const gridLayouts = nodes.reduce((accumulator, node) => {
+    const layoutsByBreakpoint = normalizeWidgetGridLayouts(node.widget.id, node.dashboardLayout?.grid);
+    Object.entries(layoutsByBreakpoint).forEach(([breakpoint, layout]) => {
+      accumulator[breakpoint] ??= [];
+      accumulator[breakpoint].push(layout);
+    });
+    return accumulator;
+  }, {});
+  DEFAULT_GRID_BREAKPOINTS.forEach((breakpoint) => {
+    gridLayouts[breakpoint] ??= [];
+  });
+  const flowNodes = nodes.map((node) => node.dashboardLayout?.flow).filter((value) => Boolean(value)).map((layout, index) => ({
+    ...layout,
+    id: layout.id || widgets[index]?.id || ""
+  }));
+  const stackOrder = [...nodes].map((node, index) => ({
+    widgetId: node.widget.id,
+    order: node.dashboardLayout?.stackOrder ?? index,
+    index
+  })).sort((left, right) => left.order - right.order || left.index - right.index).map((entry) => entry.widgetId);
+  return {
+    mode: props.mode ?? "infinite-grid",
+    selectedWidgetId,
+    widgets,
+    layouts: {
+      grid: gridLayouts,
+      flow: {
+        nodes: flowNodes,
+        viewport: props.flowViewport ?? null
+      },
+      stack: {
+        order: stackOrder,
+        activeId: props.stackActiveId ?? (selectedWidgetId && stackOrder.includes(selectedWidgetId) ? selectedWidgetId : stackOrder[0] ?? null)
+      }
+    }
+  };
+}
+function compileStandaloneWidget(nodes) {
+  if (nodes.length !== 1) {
+    throw new Error(`WidgetSurface requires exactly one widget child, received ${nodes.length}.`);
+  }
+  return nodes[0].widget;
+}
+function compileFormDefinition(props, fields) {
+  return {
+    title: props.title,
+    description: props.description,
+    submitLabel: props.submitLabel,
+    initialValues: props.initialValues,
+    fields
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getElement(spec, elementId) {
+  if (!isRecord(spec.elements)) {
+    throw new Error("Spec is missing a valid elements map.");
+  }
+  const element = spec.elements[elementId];
+  if (!isRecord(element)) {
+    throw new Error(`Spec is missing element "${elementId}".`);
+  }
+  return element;
+}
+function getRootElement(spec, expectedType) {
+  if (typeof spec.root !== "string" || spec.root.length === 0) {
+    throw new Error("Spec is missing a valid root element id.");
+  }
+  const rootElement = getElement(spec, spec.root);
+  if (rootElement.type !== expectedType) {
+    throw new Error(`Root element must be "${expectedType}".`);
+  }
+  return {
+    rootId: spec.root,
+    rootElement
+  };
+}
+function getChildIds(element) {
+  const { children } = element;
+  if (!Array.isArray(children)) {
+    return [];
+  }
+  return children.filter((value) => typeof value === "string");
+}
+function parseComponentProps(schema, props, label) {
+  const result = schema.safeParse(props ?? {});
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const detail = issue ? `${issue.path.join(".") || "props"}: ${issue.message}` : "invalid props";
+    throw new Error(`${label} has invalid props (${detail}).`);
+  }
+  return result.data;
+}
+function compileWidgetNode(spec, elementId) {
+  const element = getElement(spec, elementId);
+  if (typeof element.type !== "string" || !(element.type in WIDGET_COMPONENT_KIND_BY_NAME)) {
+    throw new Error(`Dashboard/widget child "${elementId}" must be a supported widget component.`);
+  }
+  const widgetDefinition = sharedWidgetStandardComponentDefinitions[element.type];
+  const widgetProps = parseComponentProps(
+    widgetDefinition.props,
+    element.props,
+    `${element.type} (${elementId})`
+  );
+  const { dashboardLayout, ...widget } = widgetProps;
+  return {
+    widget: {
+      ...widget,
+      kind: WIDGET_COMPONENT_KIND_BY_NAME[element.type]
+    },
+    dashboardLayout
+  };
+}
+function compileFieldNode(spec, elementId) {
+  const element = getElement(spec, elementId);
+  if (typeof element.type !== "string" || !(element.type in FIELD_COMPONENT_TYPE_BY_NAME)) {
+    throw new Error(`Form child "${elementId}" must be a supported field component.`);
+  }
+  const fieldDefinition = formStandardComponentDefinitions[element.type];
+  const fieldProps = parseComponentProps(
+    fieldDefinition.props,
+    element.props,
+    `${element.type} (${elementId})`
+  );
+  return {
+    field: {
+      ...fieldProps,
+      type: FIELD_COMPONENT_TYPE_BY_NAME[element.type]
+    }
+  };
+}
+function compileDashboardSpec(spec) {
+  const { rootElement } = getRootElement(spec, "DashboardSurface");
+  const nodes = getChildIds(rootElement).map((childId) => compileWidgetNode(spec, childId));
+  return compileDashboardValue(
+    parseComponentProps(dashboardStandardComponentDefinitions.DashboardSurface.props, rootElement.props, "DashboardSurface"),
+    nodes
+  );
+}
+function compileWidgetSpec(spec) {
+  const { rootElement } = getRootElement(spec, "WidgetSurface");
+  parseComponentProps(widgetStandardComponentDefinitions.WidgetSurface.props, rootElement.props, "WidgetSurface");
+  const nodes = getChildIds(rootElement).map((childId) => compileWidgetNode(spec, childId));
+  return compileStandaloneWidget(nodes);
+}
+function compileDataGridSpec(spec) {
+  const { rootElement } = getRootElement(spec, "WidgetSurface");
+  parseComponentProps(dataGridStandardComponentDefinitions.WidgetSurface.props, rootElement.props, "WidgetSurface");
+  const nodes = getChildIds(rootElement).map((childId) => compileWidgetNode(spec, childId));
+  const widget = compileStandaloneWidget(nodes);
+  if (widget.kind !== "data-grid") {
+    throw new Error("Data-grid mode requires the child component to be DataGridWidget.");
+  }
+  return widget;
+}
+function compileFormSpec(spec) {
+  const { rootElement } = getRootElement(spec, "FormSurface");
+  const fields = getChildIds(rootElement).map((childId) => compileFieldNode(spec, childId).field);
+  return compileFormDefinition(
+    parseComponentProps(formStandardComponentDefinitions.FormSurface.props, rootElement.props, "FormSurface"),
+    fields
+  );
+}
+function createAdapterSpec(rootId, type, props) {
+  return {
+    root: rootId,
+    elements: {
+      [rootId]: {
+        type,
+        props,
+        children: []
+      }
+    }
+  };
+}
+function createDashboardAdapterSpec(spec) {
+  return createAdapterSpec(spec.root, "DashboardSurface", { value: compileDashboardSpec(spec) });
+}
+function createWidgetAdapterSpec(spec) {
+  return createAdapterSpec(spec.root, "WidgetSurface", { widget: compileWidgetSpec(spec) });
+}
+function createDataGridAdapterSpec(spec) {
+  return createAdapterSpec(spec.root, "WidgetSurface", { widget: compileDataGridSpec(spec) });
+}
+function createFormAdapterSpec(spec) {
+  return createAdapterSpec(spec.root, "FormSurface", { definition: compileFormSpec(spec) });
+}
+
+// src/mode-entries.ts
+var import_core2 = require("@json-render/core");
+var import_image = require("@json-render/image");
+var import_react_email = require("@json-render/react-email");
+var import_react_pdf = require("@json-render/react-pdf");
+var SUPPORTED_MODES = ["dashboard", "widget", "data-grid", "form", "email", "pdf", "image"];
+var ALLOWED_WIDGET_KINDS = [
+  "line-chart",
+  "area-chart",
+  "bar-chart",
+  "funnel-chart",
+  "ring-chart",
+  "pie-chart",
+  "radar-chart",
+  "sankey-chart",
+  "choropleth-chart",
+  "awesome-stats",
+  "data-grid",
+  "live-line-chart"
+];
+var ALLOWED_FIELD_TYPES = [
+  "field-text",
+  "field-textarea",
+  "field-email",
+  "field-number",
+  "field-select",
+  "field-radioGroup",
+  "field-checkbox",
+  "field-switch",
+  "field-date",
+  "field-dateTime",
+  "field-time",
+  "field-dateRange"
+];
+var CHILD_REFERENCE_RULE = "CRITICAL: Every ID listed in a children array MUST have a matching element object in the elements map. Never reference an element ID that does not exist. Before finalizing, verify that every children entry across all elements points to an existing element key.";
+var DASHBOARD_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  `Allowed widget kinds: ${ALLOWED_WIDGET_KINDS.join(", ")}. Do not use any other kind.`,
+  "Ensure every widget query.columns covers all config data fields (xField, series fields, valueField, labelField, etc.).",
+  `Example target JSON:
+{
+  "root": "dashboard-1",
+  "elements": {
+    "dashboard-1": {
+      "type": "DashboardSurface",
+      "props": {
+        "mode": "infinite-grid",
+        "selectedWidgetId": "widget-revenue-trend"
+      },
+      "children": ["widget-revenue-trend"]
+    },
+    "widget-revenue-trend": {
+      "type": "LineChartWidget",
+      "props": {
+        "id": "widget-revenue-trend",
+        "title": "Revenue Trend",
+        "wrapInAwesomeCard": true,
+        "query": { "columns": ["date", "revenue"] },
+        "config": {
+          "xField": "date",
+          "series": [{ "field": "revenue", "label": "Revenue" }],
+          "showGrid": true,
+          "showTooltip": true
+        },
+        "dashboardLayout": {
+          "grid": { "lg": { "x": 0, "y": 0, "w": 6, "h": 4 } }
+        }
+      },
+      "children": []
+    }
+  }
+}`
+];
+var WIDGET_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  `Allowed widget kinds: ${ALLOWED_WIDGET_KINDS.join(", ")}. Do not use any other kind.`,
+  "Ensure query.columns covers all config data fields.",
+  `Example target JSON:
+{
+  "root": "widget-1",
+  "elements": {
+    "widget-1": {
+      "type": "WidgetSurface",
+      "props": {},
+      "children": ["widget-revenue-mix"]
+    },
+    "widget-revenue-mix": {
+      "type": "PieChartWidget",
+      "props": {
+        "id": "widget-revenue-mix",
+        "title": "Revenue Mix",
+        "wrapInAwesomeCard": true,
+        "query": { "columns": ["product_family", "total_amount"] },
+        "config": {
+          "labelField": "product_family",
+          "valueField": "total_amount",
+          "innerRadius": 72
+        }
+      },
+      "children": []
+    }
+  }
+}`
+];
+var DATA_GRID_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  "The root element must be WidgetSurface.",
+  "WidgetSurface must contain exactly one DataGridWidget child.",
+  "Supported component types: WidgetSurface and DataGridWidget only.",
+  "Do not use chart or stats widgets in data-grid mode.",
+  "Ensure query.columns covers every configured data-grid column key.",
+  `Example target JSON:
+{
+  "root": "data-grid-1",
+  "elements": {
+    "data-grid-1": {
+      "type": "WidgetSurface",
+      "props": {},
+      "children": ["widget-open-deals"]
+    },
+    "widget-open-deals": {
+      "type": "DataGridWidget",
+      "props": {
+        "id": "widget-open-deals",
+        "title": "Open Deals",
+        "wrapInAwesomeCard": false,
+        "query": { "columns": ["deal_name", "owner", "amount"] },
+        "config": {
+          "columns": [
+            { "key": "deal_name", "header": "Deal" },
+            { "key": "owner", "header": "Owner" },
+            { "key": "amount", "header": "Amount" }
+          ],
+          "displayMode": "table",
+          "rowHeight": "medium",
+          "enableSearch": true
+        }
+      },
+      "children": []
+    }
+  }
+}`
+];
+var FORM_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  `Allowed field types: ${ALLOWED_FIELD_TYPES.join(", ")}. Do not use any other type.`,
+  `Example target JSON:
+{
+  "root": "form-1",
+  "elements": {
+    "form-1": {
+      "type": "FormSurface",
+      "props": {
+        "title": "Lead Intake",
+        "description": "Capture the first details for a new inbound lead.",
+        "submitLabel": "Create Lead",
+        "initialValues": { "newsletter_opt_in": false }
+      },
+      "children": ["field-1", "field-2", "field-3"]
+    },
+    "field-1": {
+      "type": "TextField",
+      "props": {
+        "id": "field-1",
+        "name": "Full Name",
+        "slug": "full_name",
+        "placeholder": "Jane Doe",
+        "required": true
+      },
+      "children": []
+    },
+    "field-2": {
+      "type": "EmailField",
+      "props": {
+        "id": "field-2",
+        "name": "Email",
+        "slug": "email",
+        "placeholder": "jane@company.com",
+        "required": true
+      },
+      "children": []
+    },
+    "field-3": {
+      "type": "SelectField",
+      "props": {
+        "id": "field-3",
+        "name": "Lead Source",
+        "slug": "lead_source",
+        "options": [{ "id": "website", "name": "Website" }, { "id": "referral", "name": "Referral" }]
+      },
+      "children": []
+    }
+  }
+}`
+];
+var EMAIL_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  "Root element must be Html. Include Head and Body children.",
+  "Use email-safe structure with Container, Section, Row, Column for layout."
+];
+var PDF_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  "Root element must be Document. The first child of Document must be a Page.",
+  "Include at least one Page element. Keep structure printable and deterministic."
+];
+var IMAGE_CUSTOM_RULES = [
+  CHILD_REFERENCE_RULE,
+  "All generated IDs must be stable strings.",
+  "Root element must be Frame with explicit width and height props.",
+  "Keep structure deterministic."
+];
+var emailCatalog = (0, import_core2.defineCatalog)(import_react_email.schema, { components: import_react_email.standardComponentDefinitions, actions: {} });
+var pdfCatalog = (0, import_core2.defineCatalog)(import_react_pdf.schema, { components: import_react_pdf.standardComponentDefinitions, actions: {} });
+var imageCatalog = (0, import_core2.defineCatalog)(import_image.schema, { components: import_image.standardComponentDefinitions, actions: {} });
+var CATALOG_MAP = {
+  dashboard: { catalog: dashboardCatalog, customRules: DASHBOARD_CUSTOM_RULES },
+  widget: { catalog: widgetCatalog, customRules: WIDGET_CUSTOM_RULES },
+  "data-grid": { catalog: dataGridCatalog, customRules: DATA_GRID_CUSTOM_RULES },
+  form: { catalog: formCatalog, customRules: FORM_CUSTOM_RULES },
+  email: { catalog: emailCatalog, customRules: EMAIL_CUSTOM_RULES },
+  pdf: { catalog: pdfCatalog, customRules: PDF_CUSTOM_RULES },
+  image: { catalog: imageCatalog, customRules: IMAGE_CUSTOM_RULES }
+};
+var ROOT_ELEMENT_TYPES = {
+  dashboard: "DashboardSurface",
+  widget: "WidgetSurface",
+  "data-grid": "WidgetSurface",
+  form: "FormSurface",
+  email: "Html",
+  pdf: "Document",
+  image: "Frame"
+};
+function getCatalogForMode(mode) {
+  return CATALOG_MAP[mode];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DASHBOARD_CUSTOM_RULES,
+  DATA_GRID_CUSTOM_RULES,
+  EMAIL_CUSTOM_RULES,
+  FORM_CUSTOM_RULES,
+  IMAGE_CUSTOM_RULES,
+  PDF_CUSTOM_RULES,
+  ROOT_ELEMENT_TYPES,
+  SUPPORTED_MODES,
+  WIDGET_CUSTOM_RULES,
+  compileDashboardSpec,
+  compileDataGridSpec,
+  compileFormSpec,
+  compileWidgetSpec,
+  createDashboardAdapterSpec,
+  createDataGridAdapterSpec,
+  createFormAdapterSpec,
+  createWidgetAdapterSpec,
+  dashboardCatalog,
+  dashboardSchema,
+  dashboardStandardComponentDefinitions,
+  dataGridCatalog,
+  dataGridSchema,
+  dataGridStandardComponentDefinitions,
+  emailCatalog,
+  formCatalog,
+  formSchema,
+  formStandardComponentDefinitions,
+  getCatalogForMode,
+  imageCatalog,
+  pdfCatalog,
+  widgetCatalog,
+  widgetSchema,
+  widgetStandardComponentDefinitions
+});
+//# sourceMappingURL=index.cjs.map