@glyphjs/schemas 0.9.1 → 0.10.0

package/dist/index.cjs

@@ -28,8 +28,7 @@ var graphSchema = zod.z.object({
     })
   ),
   layout: zod.z.enum(["top-down", "left-right", "bottom-up", "radial", "force"]).optional(),
-  interactionMode: zod.z.enum(["modifier-key", "click-to-activate", "always"]).default("modifier-key"),
-  markdown: zod.z.boolean().default(false)
+  interactionMode: zod.z.enum(["modifier-key", "click-to-activate", "always"]).default("modifier-key")
 });
 var tableSchema = zod.z.object({
   columns: zod.z.array(
@@ -47,8 +46,7 @@ var tableSchema = zod.z.object({
       column: zod.z.string(),
       function: zod.z.enum(["sum", "avg", "count", "min", "max"])
     })
-  ).optional(),
-  markdown: zod.z.boolean().default(false)
+  ).optional()
 });
 var chartSchema = zod.z.object({
   type: zod.z.enum(["line", "bar", "area", "ohlc"]),
@@ -60,8 +58,7 @@ var chartSchema = zod.z.object({
   ),
   xAxis: zod.z.object({ key: zod.z.string(), label: inlineContentSchema.optional() }).optional(),
   yAxis: zod.z.object({ key: zod.z.string(), label: inlineContentSchema.optional() }).optional(),
-  legend: zod.z.boolean().optional(),
-  markdown: zod.z.boolean().default(false)
+  legend: zod.z.boolean().optional()
 });
 var relationSchema = zod.z.object({
   entities: zod.z.array(
@@ -86,26 +83,31 @@ var relationSchema = zod.z.object({
     })
   ),
   layout: zod.z.enum(["top-down", "left-right"]).optional(),
-  interactionMode: zod.z.enum(["modifier-key", "click-to-activate", "always"]).default("modifier-key"),
-  markdown: zod.z.boolean().default(false)
+  interactionMode: zod.z.enum(["modifier-key", "click-to-activate", "always"]).default("modifier-key")
+});
+var baseEventFields = {
+  title: inlineContentSchema,
+  description: inlineContentSchema.optional(),
+  type: zod.z.string().optional()
+};
+var eventWithDate = zod.z.object({
+  ...baseEventFields,
+  date: zod.z.string(),
+  label: zod.z.string().optional()
+});
+var eventWithLabel = zod.z.object({
+  ...baseEventFields,
+  date: zod.z.string().optional(),
+  label: zod.z.string()
 });
 var timelineSchema = zod.z.object({
-  events: zod.z.array(
-    zod.z.object({
-      date: zod.z.string(),
-      title: inlineContentSchema,
-      description: inlineContentSchema.optional(),
-      type: zod.z.string().optional()
-    })
-  ),
-  orientation: zod.z.enum(["vertical", "horizontal"]).optional(),
-  markdown: zod.z.boolean().default(false)
+  events: zod.z.array(zod.z.union([eventWithDate, eventWithLabel])),
+  orientation: zod.z.enum(["vertical", "horizontal"]).optional()
 });
 var calloutSchema = zod.z.object({
   type: zod.z.enum(["info", "warning", "error", "tip"]),
   title: inlineContentSchema.optional(),
-  content: inlineContentSchema,
-  markdown: zod.z.boolean().default(false)
+  content: inlineContentSchema
 });
 var tabsSchema = zod.z.object({
   tabs: zod.z.array(
@@ -114,7 +116,7 @@ var tabsSchema = zod.z.object({
       content: inlineContentSchema
     })
   ),
-  markdown: zod.z.boolean().default(false)
+  _slotChildCounts: zod.z.array(zod.z.number()).optional()
 });
 var stepsSchema = zod.z.object({
   steps: zod.z.array(
@@ -124,7 +126,7 @@ var stepsSchema = zod.z.object({
       content: inlineContentSchema
     })
   ),
-  markdown: zod.z.boolean().default(false)
+  _slotChildCounts: zod.z.array(zod.z.number()).optional()
 });
 var iconEnum = zod.z.enum([
   "server",
@@ -178,8 +180,7 @@ var kpiSchema = zod.z.object({
       unit: zod.z.string().optional()
     })
   ).min(1).max(8),
-  columns: zod.z.number().min(1).max(4).optional(),
-  markdown: zod.z.boolean().default(false)
+  columns: zod.z.number().min(1).max(4).optional()
 });
 var accordionSchema = zod.z.object({
   title: zod.z.string().optional(),
@@ -190,8 +191,7 @@ var accordionSchema = zod.z.object({
     })
   ).min(1),
   defaultOpen: zod.z.array(zod.z.number()).optional(),
-  multiple: zod.z.boolean().default(true),
-  markdown: zod.z.boolean().default(false)
+  multiple: zod.z.boolean().default(true)
 });
 var comparisonSchema = zod.z.object({
   title: zod.z.string().optional(),
@@ -206,8 +206,7 @@ var comparisonSchema = zod.z.object({
       name: zod.z.string(),
       values: zod.z.array(inlineContentSchema)
     })
-  ).min(1),
-  markdown: zod.z.boolean().default(false)
+  ).min(1)
 }).refine((data) => data.features.every((f) => f.values.length === data.options.length), {
   message: "Each feature must have one value per option"
 });
@@ -216,8 +215,7 @@ var codediffSchema = zod.z.object({
   before: zod.z.string(),
   after: zod.z.string(),
   beforeLabel: inlineContentSchema.optional(),
-  afterLabel: inlineContentSchema.optional(),
-  markdown: zod.z.boolean().default(false)
+  afterLabel: inlineContentSchema.optional()
 });
 var flowchartSchema = zod.z.object({
   title: inlineContentSchema.optional(),
@@ -236,8 +234,7 @@ var flowchartSchema = zod.z.object({
     })
   ).min(1),
   direction: zod.z.enum(["top-down", "left-right"]).default("top-down"),
-  interactionMode: zod.z.enum(["modifier-key", "click-to-activate", "always"]).default("modifier-key"),
-  markdown: zod.z.boolean().default(false)
+  interactionMode: zod.z.enum(["modifier-key", "click-to-activate", "always"]).default("modifier-key")
 });
 var fileNodeSchema = zod.z.object({
   name: zod.z.string(),
@@ -264,8 +261,7 @@ var sequenceSchema = zod.z.object({
       label: inlineContentSchema,
       type: zod.z.enum(["message", "reply", "self"]).default("message")
     })
-  ).min(1),
-  markdown: zod.z.boolean().default(false)
+  ).min(1)
 });
 var mindmapNodeSchema = zod.z.object({
   label: zod.z.string(),
@@ -284,8 +280,7 @@ var equationSchema = zod.z.object({
       expression: zod.z.string(),
       annotation: inlineContentSchema.optional()
     })
-  ).optional(),
-  markdown: zod.z.boolean().default(false)
+  ).optional()
 }).refine(
   (data) => data.expression !== void 0 || data.steps !== void 0 && data.steps.length > 0,
   { message: "Either expression or steps must be provided" }
@@ -318,8 +313,7 @@ var quizQuestion = zod.z.discriminatedUnion("type", [
 var quizSchema = zod.z.object({
   questions: zod.z.array(quizQuestion).min(1),
   showScore: zod.z.boolean().default(true),
-  title: zod.z.string().optional(),
-  markdown: zod.z.boolean().default(false)
+  title: zod.z.string().optional()
 });
 var cardActionSchema = zod.z.object({
   label: zod.z.string(),
@@ -337,8 +331,7 @@ var cardSchema = zod.z.object({
   title: zod.z.string().optional(),
   cards: zod.z.array(cardItemSchema).min(1).max(12),
   variant: zod.z.enum(["default", "outlined", "elevated"]).default("default"),
-  columns: zod.z.number().min(1).max(4).optional(),
-  markdown: zod.z.boolean().default(false)
+  columns: zod.z.number().min(1).max(4).optional()
 });
 var statItemSchema = zod.z.object({
   type: zod.z.literal("stat"),
@@ -399,16 +392,14 @@ var infographicSectionSchema = zod.z.object({
 });
 var infographicSchema = zod.z.object({
   title: zod.z.string().optional(),
-  sections: zod.z.array(infographicSectionSchema).min(1).max(8),
-  markdown: zod.z.boolean().default(false)
+  sections: zod.z.array(infographicSectionSchema).min(1).max(8)
 });
 var pollSchema = zod.z.object({
   question: inlineContentSchema,
-  options: zod.z.array(zod.z.string()).min(2).max(10),
+  options: zod.z.array(inlineContentSchema).min(2).max(10),
   multiple: zod.z.boolean().default(false),
   showResults: zod.z.boolean().default(true),
-  title: zod.z.string().optional(),
-  markdown: zod.z.boolean().default(false)
+  title: zod.z.string().optional()
 });
 var ratingItem = zod.z.object({
   label: zod.z.string(),
@@ -422,8 +413,7 @@ var ratingSchema = zod.z.object({
     low: zod.z.string(),
     high: zod.z.string()
   }).optional(),
-  items: zod.z.array(ratingItem).min(1),
-  markdown: zod.z.boolean().default(false)
+  items: zod.z.array(ratingItem).min(1)
 });
 var rankerItem = zod.z.object({
   id: zod.z.string(),
@@ -432,8 +422,7 @@ var rankerItem = zod.z.object({
 });
 var rankerSchema = zod.z.object({
   title: zod.z.string().optional(),
-  items: zod.z.array(rankerItem).min(2),
-  markdown: zod.z.boolean().default(false)
+  items: zod.z.array(rankerItem).min(2)
 });
 var sliderParameter = zod.z.object({
   id: zod.z.string(),
@@ -447,8 +436,7 @@ var sliderParameter = zod.z.object({
 var sliderSchema = zod.z.object({
   title: zod.z.string().optional(),
   layout: zod.z.enum(["vertical", "horizontal"]).default("vertical"),
-  parameters: zod.z.array(sliderParameter).min(1),
-  markdown: zod.z.boolean().default(false)
+  parameters: zod.z.array(sliderParameter).min(1)
 });
 var matrixColumn = zod.z.object({
   id: zod.z.string(),
@@ -464,8 +452,7 @@ var matrixSchema = zod.z.object({
   scale: zod.z.number().int().min(2).max(10).default(5),
   showTotals: zod.z.boolean().default(true),
   columns: zod.z.array(matrixColumn).min(1),
-  rows: zod.z.array(matrixRow).min(1),
-  markdown: zod.z.boolean().default(false)
+  rows: zod.z.array(matrixRow).min(1)
 });
 var textField = zod.z.object({
   type: zod.z.literal("text"),
@@ -519,8 +506,7 @@ var formSchema = zod.z.object({
   title: zod.z.string().optional(),
   description: inlineContentSchema.optional(),
   submitLabel: zod.z.string().default("Submit"),
-  fields: zod.z.array(formField).min(1),
-  markdown: zod.z.boolean().default(false)
+  fields: zod.z.array(formField).min(1)
 });
 var kanbanCard = zod.z.object({
   id: zod.z.string(),
@@ -537,8 +523,7 @@ var kanbanColumn = zod.z.object({
 });
 var kanbanSchema = zod.z.object({
   title: zod.z.string().optional(),
-  columns: zod.z.array(kanbanColumn).min(1),
-  markdown: zod.z.boolean().default(false)
+  columns: zod.z.array(kanbanColumn).min(1)
 });
 var annotateLabel = zod.z.object({
   name: zod.z.string(),
@@ -554,8 +539,70 @@ var annotateSchema = zod.z.object({
   title: zod.z.string().optional(),
   labels: zod.z.array(annotateLabel).min(1),
   text: zod.z.string(),
-  annotations: zod.z.array(annotation).default([]),
-  markdown: zod.z.boolean().default(false)
+  annotations: zod.z.array(annotation).default([])
+});
+var sankeyNodeSchema = zod.z.object({
+  id: zod.z.string(),
+  label: zod.z.string(),
+  color: zod.z.string().optional()
+});
+var sankeyFlowSchema = zod.z.object({
+  from: zod.z.string(),
+  to: zod.z.string(),
+  value: zod.z.number().positive(),
+  label: zod.z.string().optional()
+});
+function hasCycle(nodes, flows) {
+  const ids = new Set(nodes.map((n) => n.id));
+  const indegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    indegree.set(id, 0);
+    adjacency.set(id, []);
+  }
+  for (const flow of flows) {
+    if (!ids.has(flow.from) || !ids.has(flow.to)) continue;
+    if (flow.from === flow.to) return true;
+    const fromList = adjacency.get(flow.from);
+    if (!fromList) continue;
+    fromList.push(flow.to);
+    indegree.set(flow.to, (indegree.get(flow.to) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const [id, deg] of indegree) {
+    if (deg === 0) queue.push(id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (id === void 0) break;
+    visited += 1;
+    for (const next of adjacency.get(id) ?? []) {
+      const nextDeg = (indegree.get(next) ?? 0) - 1;
+      indegree.set(next, nextDeg);
+      if (nextDeg === 0) queue.push(next);
+    }
+  }
+  return visited !== ids.size;
+}
+var sankeySchema = zod.z.object({
+  title: zod.z.string().optional(),
+  nodes: zod.z.array(sankeyNodeSchema).min(2),
+  flows: zod.z.array(sankeyFlowSchema).min(1),
+  orientation: zod.z.enum(["left-right", "top-down"]).default("left-right"),
+  unit: zod.z.string().optional()
+}).refine(
+  (data) => {
+    const ids = new Set(data.nodes.map((n) => n.id));
+    return data.flows.every((f) => ids.has(f.from) && ids.has(f.to));
+  },
+  {
+    message: "Every flow must reference declared node IDs (from/to).",
+    path: ["flows"]
+  }
+).refine((data) => !hasCycle(data.nodes, data.flows), {
+  message: "Sankey must be a DAG \u2014 cycles are not allowed.",
+  path: ["flows"]
 });
 var columnsSchema = zod.z.object({
   children: zod.z.array(zod.z.string()).min(1),
@@ -572,6 +619,181 @@ var panelSchema = zod.z.object({
   style: zod.z.enum(["card", "bordered", "elevated", "ghost"]).optional(),
   padding: zod.z.string().optional()
 });
+var heatmapSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  rows: zod.z.array(zod.z.string()).min(1),
+  cols: zod.z.array(zod.z.string()).min(1),
+  values: zod.z.array(zod.z.array(zod.z.number().nullable())).min(1),
+  scale: zod.z.enum(["sequential", "diverging"]).default("sequential"),
+  domain: zod.z.tuple([zod.z.number(), zod.z.number()]).optional(),
+  unit: zod.z.string().optional(),
+  showValues: zod.z.boolean().default(false),
+  legend: zod.z.boolean().default(true)
+}).refine(
+  (d) => d.values.length === d.rows.length && d.values.every((r) => r.length === d.cols.length),
+  { message: "values matrix dimensions must match rows \xD7 cols" }
+);
+var funnelSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  stages: zod.z.array(
+    zod.z.object({
+      label: zod.z.string(),
+      value: zod.z.number().nonnegative(),
+      description: zod.z.string().optional()
+    })
+  ).min(2).max(12),
+  showConversion: zod.z.boolean().default(true),
+  orientation: zod.z.enum(["vertical", "horizontal"]).default("vertical"),
+  unit: zod.z.string().optional()
+}).refine(
+  (d) => {
+    for (let i = 1; i < d.stages.length; i++) {
+      const prev = d.stages[i - 1];
+      const curr = d.stages[i];
+      if (prev === void 0 || curr === void 0) return false;
+      if (curr.value > prev.value) return false;
+    }
+    return true;
+  },
+  { message: "funnel stages must be monotonically non-increasing" }
+);
+var decisiontreeNodeSchema = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.enum(["question", "outcome"]).default("question"),
+  label: zod.z.string(),
+  sentiment: zod.z.enum(["positive", "neutral", "negative"]).optional(),
+  confidence: zod.z.number().min(0).max(1).optional()
+});
+var decisiontreeEdgeSchema = zod.z.object({
+  from: zod.z.string(),
+  to: zod.z.string(),
+  condition: zod.z.string().optional()
+});
+var decisiontreeSchema = zod.z.object({
+  title: zod.z.string().optional(),
+  nodes: zod.z.array(decisiontreeNodeSchema).min(1),
+  edges: zod.z.array(decisiontreeEdgeSchema).default([]),
+  orientation: zod.z.enum(["left-right", "top-down"]).default("left-right")
+}).superRefine((data, ctx) => {
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const node of data.nodes) {
+    if (nodeIds.has(node.id)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: `duplicate node id: ${node.id}`,
+        path: ["nodes"]
+      });
+      return;
+    }
+    nodeIds.add(node.id);
+  }
+  for (const edge of data.edges) {
+    if (!nodeIds.has(edge.from)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: `edge references unknown node: ${edge.from}`,
+        path: ["edges"]
+      });
+      return;
+    }
+    if (!nodeIds.has(edge.to)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: `edge references unknown node: ${edge.to}`,
+        path: ["edges"]
+      });
+      return;
+    }
+  }
+  const parentCount = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) parentCount.set(id, 0);
+  for (const edge of data.edges) {
+    parentCount.set(edge.to, (parentCount.get(edge.to) ?? 0) + 1);
+  }
+  const roots = [];
+  for (const [id, count] of parentCount) {
+    if (count === 0) roots.push(id);
+    if (count > 1) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: `node has multiple parents (tree requires exactly one): ${id}`,
+        path: ["edges"]
+      });
+      return;
+    }
+  }
+  if (roots.length === 0) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "decision tree has no root (cycle detected)",
+      path: ["nodes"]
+    });
+    return;
+  }
+  if (roots.length > 1) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: `decision tree must have exactly one root, found ${String(roots.length)}: ${roots.join(", ")}`,
+      path: ["nodes"]
+    });
+    return;
+  }
+  const root = roots[0];
+  if (root === void 0) return;
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) adjacency.set(id, []);
+  for (const edge of data.edges) {
+    const list = adjacency.get(edge.from);
+    if (list) list.push(edge.to);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [root];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    if (visited.has(current)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        message: `cycle detected at node: ${current}`,
+        path: ["edges"]
+      });
+      return;
+    }
+    visited.add(current);
+    for (const next of adjacency.get(current) ?? []) {
+      queue.push(next);
+    }
+  }
+  if (visited.size !== nodeIds.size) {
+    const orphans = [];
+    for (const id of nodeIds) {
+      if (!visited.has(id)) orphans.push(id);
+    }
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: `orphan nodes not reachable from root: ${orphans.join(", ")}`,
+      path: ["nodes"]
+    });
+  }
+});
+var gaugeSchema = zod.z.object({
+  label: zod.z.string(),
+  value: zod.z.number(),
+  min: zod.z.number().default(0),
+  max: zod.z.number(),
+  unit: zod.z.string().optional(),
+  zones: zod.z.array(
+    zod.z.object({
+      max: zod.z.number(),
+      label: zod.z.string().optional(),
+      sentiment: zod.z.enum(["positive", "neutral", "negative"]).optional()
+    })
+  ).min(1).max(6).optional(),
+  target: zod.z.number().optional(),
+  shape: zod.z.enum(["semicircle", "full"]).default("semicircle")
+}).refine((d) => d.min < d.max, { message: "min must be less than max" }).refine((d) => d.value >= d.min && d.value <= d.max, {
+  message: "value must fall within [min, max]"
+});
 var entries = [
   ["graph", graphSchema],
   ["table", tableSchema],
@@ -602,9 +824,14 @@ var entries = [
   ["form", formSchema],
   ["kanban", kanbanSchema],
   ["annotate", annotateSchema],
+  ["sankey", sankeySchema],
   ["columns", columnsSchema],
   ["rows", rowsSchema],
-  ["panel", panelSchema]
+  ["panel", panelSchema],
+  ["heatmap", heatmapSchema],
+  ["funnel", funnelSchema],
+  ["decisiontree", decisiontreeSchema],
+  ["gauge", gaugeSchema]
 ];
 var componentSchemas = new Map(entries);
 function getJsonSchema(componentType) {
@@ -623,12 +850,16 @@ exports.codediffSchema = codediffSchema;
 exports.columnsSchema = columnsSchema;
 exports.comparisonSchema = comparisonSchema;
 exports.componentSchemas = componentSchemas;
+exports.decisiontreeSchema = decisiontreeSchema;
 exports.equationSchema = equationSchema;
 exports.filetreeSchema = filetreeSchema;
 exports.flowchartSchema = flowchartSchema;
 exports.formSchema = formSchema;
+exports.funnelSchema = funnelSchema;
+exports.gaugeSchema = gaugeSchema;
 exports.getJsonSchema = getJsonSchema;
 exports.graphSchema = graphSchema;
+exports.heatmapSchema = heatmapSchema;
 exports.infographicSchema = infographicSchema;
 exports.inlineContentSchema = inlineContentSchema;
 exports.kanbanSchema = kanbanSchema;
@@ -642,6 +873,7 @@ exports.rankerSchema = rankerSchema;
 exports.ratingSchema = ratingSchema;
 exports.relationSchema = relationSchema;
 exports.rowsSchema = rowsSchema;
+exports.sankeySchema = sankeySchema;
 exports.sequenceSchema = sequenceSchema;
 exports.sliderSchema = sliderSchema;
 exports.stepsSchema = stepsSchema;