@next-vibe/checker 1.0.11 → 1.0.12

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

@@ -0,0 +1,202 @@
+/**
+ * Code Quality List Widget Logic
+ * Shared data extraction and processing for CODE_QUALITY_LIST widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Code quality issue item
+ */
+export interface CodeQualityItem {
+  file: string;
+  line?: number;
+  column?: number;
+  severity: "error" | "warning" | "info";
+  message: string;
+  rule?: string;
+  [key: string]: WidgetData;
+}
+
+/**
+ * Summary statistics for code quality checks
+ */
+export interface CodeQualitySummary {
+  totalIssues: number;
+  totalFiles: number;
+  totalErrors: number;
+  displayedIssues: number;
+  displayedFiles: number;
+  truncatedMessage?: string;
+  currentPage: number;
+  totalPages: number;
+}
+
+/**
+ * Processed code quality list structure
+ */
+export interface ProcessedCodeQualityList {
+  items: CodeQualityItem[];
+  groupBy?: "file" | "severity" | "rule";
+}
+
+/**
+ * Extract and validate code quality list data from WidgetData
+ * CODE_QUALITY_LIST widget only handles the items array
+ * Summary is rendered by separate CONTAINER widget
+ */
+export function extractCodeQualityListData(
+  value: WidgetData,
+): ProcessedCodeQualityList | null {
+  // Handle array of issues directly
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return null;
+    }
+
+    const items = value
+      .map((item: WidgetData) => validateCodeQualityItem(item))
+      .filter((item): item is CodeQualityItem => item !== null);
+
+    if (items.length === 0) {
+      return null;
+    }
+
+    return {
+      items,
+    };
+  }
+
+  // Handle object with items array
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const items =
+      "items" in value && Array.isArray(value.items) ? value.items : [];
+    const groupBy =
+      "groupBy" in value && typeof value.groupBy === "string"
+        ? value.groupBy
+        : undefined;
+
+    const validItems = items
+      .map((item: WidgetData) => validateCodeQualityItem(item))
+      .filter((item): item is CodeQualityItem => item !== null);
+
+    if (validItems.length === 0) {
+      return null;
+    }
+
+    return {
+      items: validItems,
+      groupBy:
+        groupBy === "file" || groupBy === "severity" || groupBy === "rule"
+          ? groupBy
+          : undefined,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Validate a single code quality item
+ */
+function validateCodeQualityItem(item: WidgetData): CodeQualityItem | null {
+  if (typeof item !== "object" || item === null || Array.isArray(item)) {
+    return null;
+  }
+
+  const file = "file" in item && typeof item.file === "string" ? item.file : "";
+  const message =
+    "message" in item && typeof item.message === "string" ? item.message : "";
+
+  if (!file || !message) {
+    return null;
+  }
+
+  const line =
+    "line" in item && typeof item.line === "number" ? item.line : undefined;
+  const column =
+    "column" in item && typeof item.column === "number"
+      ? item.column
+      : undefined;
+  const severity =
+    "severity" in item && typeof item.severity === "string"
+      ? item.severity
+      : "info";
+  const rule =
+    "rule" in item && typeof item.rule === "string" ? item.rule : undefined;
+
+  return {
+    file,
+    line,
+    column,
+    severity:
+      severity === "error" || severity === "warning" || severity === "info"
+        ? severity
+        : "info",
+    message,
+    rule,
+    ...item,
+  } as CodeQualityItem;
+}
+
+/**
+ * Group items by specified field
+ */
+export function groupCodeQualityItems(
+  items: CodeQualityItem[],
+  groupBy: "file" | "severity" | "rule",
+): Map<string, CodeQualityItem[]> {
+  const groups = new Map<string, CodeQualityItem[]>();
+
+  for (const item of items) {
+    const groupKey = item[groupBy] ?? "unknown";
+    const key = String(groupKey);
+
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key)!.push(item);
+  }
+
+  return groups;
+}
+
+/**
+ * Count items by severity
+ */
+export function countCodeQualityBySeverity(items: CodeQualityItem[]): {
+  error: number;
+  warning: number;
+  info: number;
+} {
+  const counts = { error: 0, warning: 0, info: 0 };
+
+  for (const item of items) {
+    if (item.severity in counts) {
+      counts[item.severity]++;
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Sort code quality items by severity (errors first, then warnings, then info)
+ */
+export function sortBySeverity(items: CodeQualityItem[]): CodeQualityItem[] {
+  const severityOrder: Record<string, number> = {
+    error: 0,
+    warning: 1,
+    info: 2,
+  };
+  return items.toSorted((a, b) => {
+    const aOrder = severityOrder[a.severity] ?? 3;
+    const bOrder = severityOrder[b.severity] ?? 3;
+    if (aOrder !== bOrder) {
+      return aOrder - bOrder;
+    }
+    // Secondary sort by line number
+    return (a.line || 0) - (b.line || 0);
+  });
+}

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

@@ -0,0 +1,129 @@
+/**
+ * Container Widget Logic
+ * Shared data extraction and processing for CONTAINER widget
+ * Used by both React and CLI implementations
+ */
+
+import type { UnifiedField } from "../../types/endpoint";
+import { WidgetType } from "../../types/enums";
+import type { WidgetData } from "../types";
+
+/**
+ * Container layout configuration
+ */
+export interface ContainerLayout {
+  type: "vertical" | "horizontal" | "grid";
+  columns?: number;
+}
+
+/**
+ * Container configuration
+ */
+export interface ContainerConfig {
+  layout?: ContainerLayout;
+  icon?: string;
+  border?: boolean;
+  spacing?: "compact" | "normal" | "relaxed";
+}
+
+/**
+ * Processed container data structure
+ */
+export interface ProcessedContainer {
+  children: WidgetData[];
+  title?: string;
+  layout?: "vertical" | "horizontal" | "grid";
+  spacing?: number;
+}
+
+/**
+ * Extract and validate container data from WidgetData
+ */
+export function extractContainerData(
+  value: WidgetData,
+): ProcessedContainer | null {
+  // Handle array value directly (children only)
+  if (Array.isArray(value)) {
+    return {
+      children: value,
+      layout: "vertical",
+    };
+  }
+
+  // Handle object value with container properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const children =
+      "children" in value && Array.isArray(value.children)
+        ? value.children
+        : [];
+    const title =
+      "title" in value && typeof value.title === "string"
+        ? value.title
+        : undefined;
+    const layout =
+      "layout" in value && typeof value.layout === "string"
+        ? value.layout
+        : "vertical";
+    const spacing =
+      "spacing" in value && typeof value.spacing === "number"
+        ? value.spacing
+        : undefined;
+
+    if (children.length === 0) {
+      return null;
+    }
+
+    return {
+      children,
+      title,
+      layout:
+        layout === "horizontal" || layout === "grid" || layout === "vertical"
+          ? layout
+          : "vertical",
+      spacing,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get container configuration from field
+ */
+export function getContainerConfig<TKey extends string>(
+  field: UnifiedField<TKey>,
+): ContainerConfig {
+  const defaultConfig: ContainerConfig = {
+    spacing: "normal",
+  };
+
+  if (field.ui.type !== WidgetType.CONTAINER) {
+    return defaultConfig;
+  }
+
+  const config = field.ui;
+
+  const layout =
+    config.layout &&
+    typeof config.layout === "object" &&
+    !Array.isArray(config.layout) &&
+    "type" in config.layout
+      ? (config.layout as ContainerLayout)
+      : { type: "vertical" as const, columns: 1 };
+
+  const icon = typeof config.icon === "string" ? config.icon : undefined;
+  const border = typeof config.border === "boolean" ? config.border : false;
+  const spacing =
+    config.spacing === "compact" ||
+    config.spacing === "normal" ||
+    config.spacing === "relaxed"
+      ? config.spacing
+      : "normal";
+
+  return {
+    layout,
+    icon,
+    border,
+    spacing,
+  };
+}

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

@@ -0,0 +1,81 @@
+/**
+ * Data Card Widget Logic
+ * Shared data extraction and processing for DATA_CARD widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Processed data card structure
+ */
+export interface ProcessedDataCard {
+  title: string;
+  description?: string;
+  fields: Array<{
+    label: string;
+    value: WidgetData;
+  }>;
+  actions?: Array<{
+    label: string;
+    action: string;
+  }>;
+}
+
+/**
+ * Extract and validate data card from WidgetData
+ */
+export function extractDataCardData(
+  value: WidgetData,
+): ProcessedDataCard | null {
+  // Handle object value with card properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const title =
+      "title" in value && typeof value.title === "string" ? value.title : "";
+    const description =
+      "description" in value && typeof value.description === "string"
+        ? value.description
+        : undefined;
+    const fields =
+      "fields" in value && Array.isArray(value.fields) ? value.fields : [];
+    const actions =
+      "actions" in value && Array.isArray(value.actions)
+        ? value.actions
+        : undefined;
+
+    if (!title) {
+      return null;
+    }
+
+    // Validate fields
+    const validFields = fields
+      .filter((f) => typeof f === "object" && f !== null)
+      .map((f) => ({
+        label:
+          "label" in f && typeof f.label === "string" ? f.label : "Unknown",
+        value: "value" in f ? f.value : null,
+      }));
+
+    // Validate actions if present
+    const validActions = actions
+      ? actions
+          .filter((a) => typeof a === "object" && a !== null)
+          .map((a) => ({
+            label:
+              "label" in a && typeof a.label === "string" ? a.label : "Action",
+            action:
+              "action" in a && typeof a.action === "string" ? a.action : "",
+          }))
+      : undefined;
+
+    return {
+      title,
+      description,
+      fields: validFields,
+      actions: validActions,
+    };
+  }
+
+  // Invalid type
+  return null;
+}

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

@@ -0,0 +1,258 @@
+/**
+ * Data Cards Widget Logic
+ * Shared data extraction and processing for DATA_CARDS widget
+ * Used by both React and CLI implementations
+ */
+
+import type { UnifiedField } from "../../types/endpoint";
+import { WidgetType } from "../../types/enums";
+import type { WidgetData } from "../types";
+
+/**
+ * Individual card item
+ */
+export interface CardItem {
+  [key: string]: WidgetData;
+  line?: number;
+  column?: number;
+  severity?: string;
+  message?: string;
+  rule?: string;
+  file?: string;
+}
+
+/**
+ * Type guard to check if a value is a CardItem
+ */
+function isCardItem(item: WidgetData): item is CardItem {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+
+/**
+ * Card configuration
+ */
+export interface CardConfig {
+  layout: {
+    columns: number;
+    spacing: string;
+  };
+  groupBy?: string;
+  cardTemplate: string;
+  showSummary: boolean;
+  summaryTemplate?: string;
+  itemConfig: {
+    template: string;
+    size: string;
+    spacing: string;
+  };
+}
+
+/**
+ * Processed data cards structure
+ */
+export interface ProcessedDataCards {
+  cards: CardItem[];
+  columns: number;
+  title?: string;
+}
+
+/**
+ * Get card configuration from field
+ */
+export function getCardsConfig<TKey extends string>(
+  field: UnifiedField<TKey>,
+): CardConfig {
+  const defaultConfig: CardConfig = {
+    layout: { columns: 2, spacing: "normal" },
+    cardTemplate: "default",
+    showSummary: false,
+    itemConfig: { template: "default", size: "medium", spacing: "normal" },
+  };
+
+  if (field.ui.type !== WidgetType.DATA_CARDS) {
+    return defaultConfig;
+  }
+
+  const config = field.ui;
+
+  // Handle layout config - ensure it's an object
+  let layout: { columns: number; spacing: string } = {
+    columns: 2,
+    spacing: "normal",
+  };
+  if (
+    config.layout &&
+    typeof config.layout === "object" &&
+    "columns" in config.layout &&
+    "spacing" in config.layout
+  ) {
+    layout = {
+      columns:
+        typeof config.layout.columns === "number" ? config.layout.columns : 2,
+      spacing:
+        typeof config.layout.spacing === "string"
+          ? config.layout.spacing
+          : "normal",
+    };
+  }
+
+  return {
+    layout,
+    groupBy: config.groupBy !== undefined ? String(config.groupBy) : undefined,
+    cardTemplate:
+      config.cardTemplate !== undefined
+        ? String(config.cardTemplate)
+        : "default",
+    showSummary:
+      config.showSummary !== undefined ? Boolean(config.showSummary) : false,
+    summaryTemplate:
+      config.summaryTemplate !== undefined
+        ? String(config.summaryTemplate)
+        : undefined,
+    itemConfig:
+      config.itemConfig &&
+      typeof config.itemConfig === "object" &&
+      "template" in config.itemConfig &&
+      "size" in config.itemConfig &&
+      "spacing" in config.itemConfig
+        ? {
+            template:
+              typeof config.itemConfig.template === "string"
+                ? config.itemConfig.template
+                : "default",
+            size:
+              typeof config.itemConfig.size === "string"
+                ? config.itemConfig.size
+                : "medium",
+            spacing:
+              typeof config.itemConfig.spacing === "string"
+                ? config.itemConfig.spacing
+                : "normal",
+          }
+        : {
+            template: "default",
+            size: "medium",
+            spacing: "normal",
+          },
+  };
+}
+
+/**
+ * Group card data by specified field
+ */
+export function groupCardData(
+  data: CardItem[],
+  groupBy: string,
+): Map<string, CardItem[]> {
+  const groups = new Map<string, CardItem[]>();
+
+  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";
+    } else if (groupValue !== null && groupValue !== undefined) {
+      groupKey = "unknown";
+    }
+    if (!groups.has(groupKey)) {
+      groups.set(groupKey, []);
+    }
+    groups.get(groupKey)!.push(item);
+  }
+
+  return groups;
+}
+
+/**
+ * Count cards by severity
+ */
+export function countBySeverity(data: CardItem[]): Record<string, number> {
+  const counts: Record<string, number> = { error: 0, warning: 0, info: 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]++;
+    } else {
+      counts[severity] = 1;
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Extract and validate data cards from WidgetData
+ */
+export function extractDataCardsData(
+  value: WidgetData,
+): ProcessedDataCards | null {
+  // Handle array of cards directly
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return null;
+    }
+
+    const filteredCards: CardItem[] = [];
+    for (const item of value) {
+      if (isCardItem(item)) {
+        filteredCards.push(item);
+      }
+    }
+
+    if (filteredCards.length === 0) {
+      return null;
+    }
+
+    return {
+      cards: filteredCards,
+      columns: 3,
+    };
+  }
+
+  // Handle object with cards array
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const cards =
+      "cards" in value && Array.isArray(value.cards) ? value.cards : [];
+    const columns =
+      "columns" in value && typeof value.columns === "number"
+        ? value.columns
+        : 3;
+    const title =
+      "title" in value && typeof value.title === "string"
+        ? value.title
+        : undefined;
+
+    const validCards = cards.filter(
+      (item): item is CardItem =>
+        typeof item === "object" && item !== null && !Array.isArray(item),
+    );
+
+    if (validCards.length === 0) {
+      return null;
+    }
+
+    return {
+      cards: validCards,
+      columns: Math.max(1, Math.min(4, columns)),
+      title,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get grid columns count
+ */
+export function getDataCardsColumns(columns: number): number {
+  return Math.max(1, Math.min(4, columns));
+}