@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/unified-interface/shared/widgets/helpers.ts

@@ -0,0 +1,80 @@
+/**
+ * Widget System Helper Types
+ *
+ * This file contains helper types for working with widgets.
+ * For widget configurations, import from widget-configs.ts.
+ */
+
+import type {
+  ComponentSize,
+  ComponentVariant,
+  InterfaceContext,
+  SpacingSize,
+} from "../types/enums";
+import type {
+  ChartWidgetConfig,
+  ContainerWidgetConfig,
+  DataTableWidgetConfig,
+  FormFieldWidgetConfig,
+  MetricCardWidgetConfig,
+  WidgetConfig,
+} from "./configs";
+
+/**
+ * Widget preset for common patterns
+ */
+export interface WidgetPreset<TKey extends string> {
+  name: string;
+  description: TKey;
+  widgets: WidgetConfig<TKey>[];
+  contexts?: InterfaceContext[];
+}
+
+/**
+ * Widget theme configuration
+ */
+export interface WidgetTheme {
+  name: string;
+  colors: Record<ComponentVariant, string>;
+  spacing: Record<SpacingSize, string>;
+  sizes: Record<ComponentSize, Record<string, string>>;
+  typography: Record<string, Record<string, string>>;
+}
+
+/**
+ * Widget factory for creating common widget patterns
+ */
+export interface WidgetFactory<TKey extends string> {
+  createFormField(
+    config: Partial<FormFieldWidgetConfig<TKey>>,
+  ): FormFieldWidgetConfig<TKey>;
+  createDataTable(
+    config: Partial<DataTableWidgetConfig<TKey>>,
+  ): DataTableWidgetConfig<TKey>;
+  createMetricCard(
+    config: Partial<MetricCardWidgetConfig<TKey>>,
+  ): MetricCardWidgetConfig<TKey>;
+  createChart(
+    config: Partial<ChartWidgetConfig<TKey>>,
+  ): ChartWidgetConfig<TKey>;
+  createContainer(
+    config: Partial<ContainerWidgetConfig<TKey>>,
+  ): ContainerWidgetConfig<TKey>;
+}
+
+/**
+ * Widget validation result
+ */
+export interface WidgetValidationResult {
+  valid: boolean;
+  errors: Array<{
+    path: string;
+    message: string;
+    code: string;
+  }>;
+  warnings: Array<{
+    path: string;
+    message: string;
+    code: string;
+  }>;
+}

package/src/app/api/[locale]/system/unified-interface/shared/widgets/logic/accordion.ts

@@ -0,0 +1,82 @@
+/**
+ * Accordion Widget Logic
+ * Shared data extraction and processing for ACCORDION widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Accordion item structure
+ */
+export interface AccordionItem {
+  id: string;
+  title: string;
+  content: WidgetData;
+  expanded?: boolean;
+}
+
+/**
+ * Processed accordion data structure
+ */
+export interface ProcessedAccordion {
+  items: AccordionItem[];
+  allowMultiple?: boolean;
+  variant?: "default" | "bordered" | "separated";
+}
+
+/**
+ * Extract and validate accordion data from WidgetData
+ */
+export function extractAccordionData(
+  value: WidgetData,
+): ProcessedAccordion | null {
+  // Handle object value with accordion properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const items =
+      "items" in value && Array.isArray(value.items) ? value.items : [];
+    const allowMultiple =
+      "allowMultiple" in value && typeof value.allowMultiple === "boolean"
+        ? value.allowMultiple
+        : false;
+    const variant =
+      "variant" in value && typeof value.variant === "string"
+        ? (value.variant as "default" | "bordered" | "separated")
+        : "default";
+
+    // Validate items
+    const validItems = items
+      .filter((item) => typeof item === "object" && item !== null)
+      .map((item) => ({
+        id: "id" in item && typeof item.id === "string" ? item.id : "",
+        title:
+          "title" in item && typeof item.title === "string" ? item.title : "",
+        content: "content" in item ? item.content : null,
+        expanded:
+          "expanded" in item && typeof item.expanded === "boolean"
+            ? item.expanded
+            : false,
+      }))
+      .filter((item) => item.id && item.title);
+
+    if (validItems.length === 0) {
+      return null;
+    }
+
+    return {
+      items: validItems,
+      allowMultiple,
+      variant,
+    };
+  }
+
+  // Invalid type
+  return null;
+}
+
+/**
+ * Get expanded items from accordion
+ */
+export function getExpandedItems(data: ProcessedAccordion): AccordionItem[] {
+  return data.items.filter((item) => item.expanded);
+}

package/src/app/api/[locale]/system/unified-interface/shared/widgets/logic/avatar.ts

@@ -0,0 +1,75 @@
+/**
+ * Avatar Widget Logic
+ * Shared data extraction and processing for AVATAR widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Processed avatar data structure
+ */
+export interface ProcessedAvatar {
+  src?: string;
+  alt: string;
+  fallback: string;
+  size?: "sm" | "md" | "lg";
+}
+
+/**
+ * Extract and validate avatar data from WidgetData
+ */
+export function extractAvatarData(value: WidgetData): ProcessedAvatar | null {
+  // Handle string value directly (image URL)
+  if (typeof value === "string") {
+    return {
+      src: value,
+      alt: "Avatar",
+      fallback: getInitials(value),
+      size: "md",
+    };
+  }
+
+  // Handle object value with avatar properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const src =
+      "src" in value && typeof value.src === "string" ? value.src : "";
+    const alt =
+      "alt" in value && typeof value.alt === "string" ? value.alt : "Avatar";
+    const fallback =
+      "fallback" in value && typeof value.fallback === "string"
+        ? value.fallback
+        : getInitials(alt);
+    const size =
+      "size" in value && typeof value.size === "string"
+        ? (value.size as "sm" | "md" | "lg")
+        : "md";
+
+    return {
+      src: src || undefined,
+      alt,
+      fallback,
+      size,
+    };
+  }
+
+  // Invalid type
+  return null;
+}
+
+/**
+ * Get initials from a name
+ */
+export function getInitials(name: string): string {
+  if (!name) {
+    return "?";
+  }
+
+  const parts = name.trim().split(/\s+/);
+
+  if (parts.length === 1) {
+    return parts[0].charAt(0).toUpperCase();
+  }
+
+  return (parts[0].charAt(0) + parts[parts.length - 1].charAt(0)).toUpperCase();
+}

package/src/app/api/[locale]/system/unified-interface/shared/widgets/logic/badge.ts

@@ -0,0 +1,89 @@
+/**
+ * Badge Widget Logic
+ * Shared data extraction and processing for BADGE widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Badge variants for styling
+ */
+export type BadgeVariant =
+  | "default"
+  | "primary"
+  | "secondary"
+  | "success"
+  | "warning"
+  | "error"
+  | "destructive";
+
+/**
+ * Processed badge data structure
+ */
+export interface ProcessedBadge {
+  text: string;
+  variant: BadgeVariant;
+  icon?: string;
+}
+
+/**
+ * Extract and validate badge data from WidgetData
+ */
+export function extractBadgeData(value: WidgetData): ProcessedBadge | null {
+  // Handle string value directly
+  if (typeof value === "string") {
+    return {
+      text: value,
+      variant: "default",
+    };
+  }
+
+  // Handle object value with badge properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const text =
+      "text" in value && typeof value.text === "string" ? value.text : "";
+    const variant =
+      "variant" in value && typeof value.variant === "string"
+        ? (value.variant as BadgeVariant)
+        : "default";
+    const icon =
+      "icon" in value && typeof value.icon === "string"
+        ? value.icon
+        : undefined;
+
+    if (!text) {
+      return null;
+    }
+
+    return {
+      text,
+      variant,
+      icon,
+    };
+  }
+
+  // Invalid type
+  return null;
+}
+
+/**
+ * Get color for badge variant
+ */
+export function getBadgeColor(variant: BadgeVariant): string {
+  switch (variant) {
+    case "primary":
+      return "blue";
+    case "secondary":
+      return "gray";
+    case "success":
+      return "green";
+    case "warning":
+      return "yellow";
+    case "error":
+    case "destructive":
+      return "red";
+    default:
+      return "gray";
+  }
+}

package/src/app/api/[locale]/system/unified-interface/shared/widgets/logic/code-output.ts

@@ -0,0 +1,302 @@
+/**
+ * Code Output Widget Logic
+ * Shared data extraction and processing for CODE_OUTPUT widget
+ * Used by both React and CLI implementations
+ */
+
+import type { UnifiedField } from "../../types/endpoint";
+import { WidgetType } from "../../types/enums";
+import type { WidgetData } from "../types";
+
+/**
+ * Code output item interface (for linter/code quality output)
+ */
+export interface CodeOutputItem {
+  [key: string]: WidgetData;
+  line?: number;
+  column?: number;
+  severity?: string;
+  message?: string;
+  rule?: string;
+  file?: string;
+}
+
+/**
+ * Code output configuration
+ */
+export interface CodeOutputConfig {
+  format: "eslint" | "generic" | "json" | "table";
+  groupBy?: string;
+  showSummary: boolean;
+  showLineNumbers: boolean;
+  colorScheme: "auto" | "light" | "dark";
+  severityIcons: Record<string, string>;
+  summaryTemplate?: string;
+}
+
+/**
+ * Processed code output data structure (simple code display)
+ */
+export interface ProcessedCodeOutput {
+  code: string;
+  language: string;
+  showLineNumbers: boolean;
+  highlightLines: number[];
+  theme: string;
+}
+
+/**
+ * Extract code output configuration from field
+ */
+export function getCodeOutputConfig<const TKey extends string>(
+  field: UnifiedField<TKey>,
+): CodeOutputConfig {
+  const defaultConfig: CodeOutputConfig = {
+    format: "generic",
+    showSummary: true,
+    showLineNumbers: false,
+    colorScheme: "auto",
+    severityIcons: {
+      error: "✖ ",
+      warning: "⚠ ",
+      info: "ℹ ",
+      success: "✓ ",
+    },
+  };
+
+  if (field.ui.type !== WidgetType.CODE_OUTPUT) {
+    return defaultConfig;
+  }
+
+  const config = field.ui;
+
+  const formatValue = config.outputFormat || config.format;
+  const format =
+    typeof formatValue === "string" &&
+    (formatValue === "eslint" ||
+      formatValue === "generic" ||
+      formatValue === "json" ||
+      formatValue === "table")
+      ? formatValue
+      : "generic";
+
+  const showSummary =
+    typeof config.showSummary === "boolean" ? config.showSummary : true;
+
+  const colorSchemeValue =
+    "colorScheme" in config ? config.colorScheme : undefined;
+  const colorScheme =
+    typeof colorSchemeValue === "string" &&
+    (colorSchemeValue === "auto" ||
+      colorSchemeValue === "light" ||
+      colorSchemeValue === "dark")
+      ? colorSchemeValue
+      : "auto";
+
+  let severityIcons: Record<string, string> = {
+    error: "✖ ",
+    warning: "⚠ ",
+    info: "ℹ ",
+    success: "✓ ",
+  };
+
+  if (
+    "severityIcons" in config &&
+    typeof config.severityIcons === "object" &&
+    config.severityIcons !== null &&
+    !Array.isArray(config.severityIcons)
+  ) {
+    const icons: Record<string, string> = {};
+    for (const [key, val] of Object.entries(config.severityIcons)) {
+      if (typeof val === "string") {
+        icons[key] = val;
+      }
+    }
+    if (Object.keys(icons).length > 0) {
+      severityIcons = icons;
+    }
+  }
+
+  const groupBy =
+    "groupBy" in config && typeof config.groupBy === "string"
+      ? config.groupBy
+      : undefined;
+
+  const summaryTemplate =
+    "summaryTemplate" in config && typeof config.summaryTemplate === "string"
+      ? config.summaryTemplate
+      : undefined;
+
+  return {
+    format,
+    groupBy,
+    showSummary,
+    showLineNumbers: false,
+    colorScheme,
+    severityIcons,
+    summaryTemplate,
+  };
+}
+
+/**
+ * Group code output data by specified field
+ */
+export function groupCodeOutputData(
+  data: CodeOutputItem[],
+  groupBy: string,
+): Map<string, CodeOutputItem[]> {
+  const groups = new Map<string, CodeOutputItem[]>();
+
+  for (const item of data) {
+    const groupValue = item[groupBy];
+    let groupKey = "unknown";
+    if (typeof groupValue === "string") {
+      groupKey = groupValue;
+    } else if (typeof groupValue === "number") {
+      groupKey = String(groupValue);
+    } else if (typeof groupValue === "boolean") {
+      groupKey = groupValue ? "true" : "false";
+    }
+
+    if (!groups.has(groupKey)) {
+      groups.set(groupKey, []);
+    }
+    groups.get(groupKey)!.push(item);
+  }
+
+  return groups;
+}
+
+/**
+ * Count items by severity
+ */
+export function countCodeOutputBySeverity(
+  data: CodeOutputItem[],
+): Record<string, number> {
+  const counts = { error: 0, warning: 0, info: 0, success: 0 };
+
+  for (const item of data) {
+    const severityValue = item.severity;
+    let severity = "info";
+    if (typeof severityValue === "string") {
+      severity = severityValue;
+    }
+    if (severity in counts) {
+      counts[severity as keyof typeof counts]++;
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Build table data structure from code output items
+ */
+export function buildTableData(data: CodeOutputItem[]): {
+  keys: string[];
+  rows: Array<Record<string, string>>;
+} {
+  if (data.length === 0) {
+    return { keys: [], rows: [] };
+  }
+
+  const keys = Object.keys(data[0]);
+  const rows = data.map((item) => {
+    const row: Record<string, string> = {};
+    for (const key of keys) {
+      const val = item[key];
+      if (typeof val === "string") {
+        row[key] = val;
+      } else if (typeof val === "number") {
+        row[key] = String(val);
+      } else if (typeof val === "boolean") {
+        row[key] = val ? "true" : "false";
+      } else {
+        row[key] = "";
+      }
+    }
+    return row;
+  });
+
+  return { keys, rows };
+}
+
+/**
+ * Extract and validate code output data from WidgetData
+ * Handles both string (simple code) and object (full config) formats
+ */
+export function extractCodeOutputData(
+  value: WidgetData,
+  defaultTheme = "light",
+): ProcessedCodeOutput | null {
+  // Handle string value directly (simple code string)
+  if (typeof value === "string") {
+    return {
+      code: value,
+      language: "text",
+      showLineNumbers: false,
+      highlightLines: [],
+      theme: defaultTheme,
+    };
+  }
+
+  // Handle object value with code properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const code =
+      "code" in value && typeof value.code === "string" ? value.code : "";
+    const language =
+      "language" in value && typeof value.language === "string"
+        ? value.language
+        : "text";
+    const showLineNumbers =
+      "showLineNumbers" in value && typeof value.showLineNumbers === "boolean"
+        ? value.showLineNumbers
+        : false;
+
+    // Extract and validate highlightLines array
+    const rawHighlightLines =
+      "highlightLines" in value && Array.isArray(value.highlightLines)
+        ? value.highlightLines
+        : [];
+    const highlightLines = rawHighlightLines.filter(
+      (item): item is number => typeof item === "number",
+    );
+
+    const theme =
+      "theme" in value && typeof value.theme === "string"
+        ? value.theme
+        : defaultTheme;
+
+    if (!code) {
+      return null;
+    }
+
+    return {
+      code,
+      language,
+      showLineNumbers,
+      highlightLines,
+      theme,
+    };
+  }
+
+  // Invalid type
+  return null;
+}
+
+/**
+ * Split code into lines for rendering
+ */
+export function splitCodeIntoLines(code: string): string[] {
+  return code.split("\n");
+}
+
+/**
+ * Check if a line should be highlighted
+ */
+export function isLineHighlighted(
+  lineNumber: number,
+  highlightLines: number[],
+): boolean {
+  return highlightLines.includes(lineNumber);
+}