@next-vibe/checker 1.0.11 → 1.0.12

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

@@ -0,0 +1,123 @@
+/**
+ * Data List Widget Logic
+ * Shared data extraction and processing for DATA_LIST widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * List item type
+ */
+export interface ListItem {
+  [key: string]: WidgetData;
+}
+
+/**
+ * Type guard to check if a value is a ListItem
+ */
+function isListItem(item: WidgetData): item is ListItem {
+  return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+
+/**
+ * Processed data list structure
+ */
+export interface ProcessedDataList {
+  items: ListItem[];
+  title?: string;
+  showBullets: boolean;
+  maxItems?: number;
+}
+
+/**
+ * Extract and validate data list from WidgetData
+ */
+export function extractDataListData(
+  value: WidgetData,
+): ProcessedDataList | null {
+  // Handle array of items directly
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return null;
+    }
+
+    const filteredItems: ListItem[] = [];
+    for (const item of value) {
+      if (isListItem(item)) {
+        filteredItems.push(item);
+      }
+    }
+
+    if (filteredItems.length === 0) {
+      return null;
+    }
+
+    return {
+      items: filteredItems,
+      showBullets: true,
+    };
+  }
+
+  // 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 title =
+      "title" in value && typeof value.title === "string"
+        ? value.title
+        : undefined;
+    const showBullets =
+      "showBullets" in value && typeof value.showBullets === "boolean"
+        ? value.showBullets
+        : true;
+    const maxItems =
+      "maxItems" in value && typeof value.maxItems === "number"
+        ? value.maxItems
+        : undefined;
+
+    const validItems = items.filter(
+      (item): item is ListItem =>
+        typeof item === "object" && item !== null && !Array.isArray(item),
+    );
+
+    if (validItems.length === 0) {
+      return null;
+    }
+
+    return {
+      items: validItems,
+      title,
+      showBullets,
+      maxItems,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get display items based on maxItems limit
+ */
+export function getListDisplayItems(
+  items: ListItem[],
+  maxItems?: number,
+): ListItem[] {
+  if (!maxItems || items.length <= maxItems) {
+    return items;
+  }
+  return items.slice(0, maxItems);
+}
+
+/**
+ * Get remaining items count
+ */
+export function getRemainingListItemsCount(
+  totalItems: number,
+  maxItems?: number,
+): number {
+  if (!maxItems || totalItems <= maxItems) {
+    return 0;
+  }
+  return totalItems - maxItems;
+}

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

@@ -0,0 +1,387 @@
+/**
+ * Data Table Widget Logic
+ * Shared data extraction and processing for DATA_TABLE widget
+ * Used by both React and CLI implementations
+ */
+
+import type { CountryLanguage } from "@/i18n/core/config";
+
+import type { UnifiedField } from "../../types/endpoint";
+import { FieldDataType, WidgetType } from "../../types/enums";
+import type { WidgetData } from "../types";
+
+/**
+ * Table row type
+ */
+export interface TableRow {
+  [key: string]: WidgetData;
+}
+
+/**
+ * Table column definition
+ */
+export interface TableColumn<TKey extends string> {
+  key: string;
+  label: NoInfer<TKey>;
+  type?: FieldDataType;
+  width?: string;
+  align?: "left" | "center" | "right";
+  formatter?: (value: WidgetData) => string;
+}
+
+/**
+ * Table rendering configuration
+ */
+export interface TableRenderConfig<TKey extends string> {
+  columns: TableColumn<TKey>[];
+  pagination: { enabled: boolean; pageSize: number };
+  sorting: {
+    enabled: boolean;
+    defaultSort?: { key: string; direction: "asc" | "desc" };
+  };
+  filtering: { enabled: boolean };
+}
+
+/**
+ * Processed data table structure
+ */
+export interface ProcessedDataTable<TKey extends string> {
+  rows: TableRow[];
+  columns: TableColumn<TKey>[];
+}
+
+/**
+ * Extract and validate data table from WidgetData
+ */
+export function extractDataTableData<TKey extends string>(
+  value: WidgetData,
+): ProcessedDataTable<TKey> | null {
+  // Handle array of objects (auto-detect columns)
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return null;
+    }
+
+    // Auto-detect columns from first row
+    const firstRow = value[0];
+    if (
+      typeof firstRow === "object" &&
+      firstRow !== null &&
+      !Array.isArray(firstRow)
+    ) {
+      const columns: TableColumn<TKey>[] = Object.keys(firstRow).map((key) => ({
+        key,
+        label: key as TKey,
+      }));
+
+      const rows = value.filter(
+        (item): item is TableRow =>
+          item !== undefined &&
+          typeof item === "object" &&
+          item !== null &&
+          !Array.isArray(item),
+      ) as TableRow[];
+
+      return {
+        rows,
+        columns,
+      };
+    }
+
+    return null;
+  }
+
+  // Handle object with rows and columns
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const rows = "rows" in value && Array.isArray(value.rows) ? value.rows : [];
+    const columns =
+      "columns" in value && Array.isArray(value.columns) ? value.columns : [];
+
+    // Validate rows
+    const validRows = rows.filter(
+      (item): item is TableRow =>
+        typeof item === "object" && item !== null && !Array.isArray(item),
+    );
+
+    // Validate columns
+    const validColumns = columns
+      .map((col: WidgetData) => {
+        if (typeof col !== "object" || col === null || Array.isArray(col)) {
+          return null;
+        }
+
+        const key = "key" in col && typeof col.key === "string" ? col.key : "";
+        const label =
+          "label" in col && typeof col.label === "string" ? col.label : key;
+
+        if (!key) {
+          return null;
+        }
+
+        return { key, label };
+      })
+      .filter((col): col is TableColumn<TKey> => col !== null);
+
+    if (validRows.length === 0) {
+      return null;
+    }
+
+    // If no columns provided, auto-detect from first row
+    if (validColumns.length === 0 && validRows.length > 0) {
+      const firstRow = validRows[0];
+      const autoColumns: TableColumn<TKey>[] = Object.keys(firstRow).map(
+        (key) => ({
+          key,
+          label: key as TKey,
+        }),
+      );
+      return {
+        rows: validRows,
+        columns: autoColumns,
+      };
+    }
+
+    return {
+      rows: validRows,
+      columns: validColumns,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get cell value from row
+ */
+export function getCellValue(row: TableRow, columnKey: string): WidgetData {
+  return row[columnKey];
+}
+
+/**
+ * Get table configuration from field
+ */
+export function getTableConfig<TKey extends string>(
+  field: UnifiedField<TKey>,
+): TableRenderConfig<TKey> {
+  const defaultConfig: TableRenderConfig<TKey> = {
+    columns: [],
+    pagination: { enabled: false, pageSize: 50 },
+    sorting: { enabled: false },
+    filtering: { enabled: false },
+  };
+
+  if (field.ui.type !== WidgetType.DATA_TABLE) {
+    return defaultConfig;
+  }
+
+  const config = field.ui;
+
+  const columns: TableColumn<TKey>[] =
+    config.columns?.map((col) => ({
+      key: col.key,
+      label: col.label,
+      type: FieldDataType.TEXT,
+      width: typeof col.width === "string" ? col.width : undefined,
+      align: col.align || ("left" as const),
+    })) || [];
+
+  // Extract and type-check pagination config
+  const paginationValue = config.pagination;
+  let pagination: { enabled: boolean; pageSize: number } = {
+    enabled: false,
+    pageSize: 50,
+  };
+  if (
+    typeof paginationValue === "object" &&
+    paginationValue !== null &&
+    !Array.isArray(paginationValue)
+  ) {
+    const paginationObj = paginationValue;
+    if ("enabled" in paginationObj && "pageSize" in paginationObj) {
+      const enabledVal = paginationObj.enabled;
+      const pageSizeVal = paginationObj.pageSize;
+      if (typeof enabledVal === "boolean" && typeof pageSizeVal === "number") {
+        pagination = { enabled: enabledVal, pageSize: pageSizeVal };
+      }
+    }
+  }
+
+  // Extract and type-check sorting config
+  const sortingValue = config.sorting;
+  let sorting: {
+    enabled: boolean;
+    defaultSort?: { key: string; direction: "asc" | "desc" };
+  } = {
+    enabled: false,
+  };
+  if (
+    typeof sortingValue === "object" &&
+    sortingValue !== null &&
+    !Array.isArray(sortingValue)
+  ) {
+    const sortingObj = sortingValue;
+    if ("enabled" in sortingObj) {
+      const enabledVal = sortingObj.enabled;
+      if (typeof enabledVal === "boolean") {
+        sorting.enabled = enabledVal;
+      }
+    }
+  }
+
+  // Extract and type-check filtering config
+  const filteringValue = config.filtering;
+  let filtering: { enabled: boolean } = { enabled: false };
+  if (
+    typeof filteringValue === "object" &&
+    filteringValue !== null &&
+    !Array.isArray(filteringValue)
+  ) {
+    const filteringObj = filteringValue;
+    if ("enabled" in filteringObj) {
+      const enabledVal = filteringObj.enabled;
+      if (typeof enabledVal === "boolean") {
+        filtering = { enabled: enabledVal };
+      }
+    }
+  }
+
+  return {
+    columns,
+    pagination,
+    sorting,
+    filtering,
+  };
+}
+
+/**
+ * Detect field data type from value
+ */
+export function detectFieldType(value: WidgetData): FieldDataType {
+  if (typeof value === "number") {
+    return FieldDataType.NUMBER;
+  }
+  if (typeof value === "boolean") {
+    return FieldDataType.BOOLEAN;
+  }
+  if (Array.isArray(value)) {
+    return FieldDataType.ARRAY;
+  }
+  if (value && typeof value === "object") {
+    return FieldDataType.OBJECT;
+  }
+  if (typeof value === "string" && !isNaN(Date.parse(value))) {
+    return FieldDataType.DATE;
+  }
+  return FieldDataType.TEXT;
+}
+
+/**
+ * Calculate column widths based on content
+ */
+export function calculateColumnWidths<TKey extends string>(
+  data: TableRow[],
+  config: TableRenderConfig<TKey>,
+  maxWidth: number,
+): number[] {
+  const availableWidth = maxWidth - (config.columns.length - 1) * 3; // Account for separators
+
+  return config.columns.map((col: TableColumn<TKey>) => {
+    if (col.width?.endsWith("%")) {
+      const percentage = parseInt(col.width.replace("%", ""), 10) / 100;
+      return Math.floor(availableWidth * percentage);
+    }
+
+    // Auto-calculate based on content
+    const headerWidth = col.label.length;
+    const maxContentWidth = Math.max(
+      ...data.slice(0, 10).map((row) => {
+        const value = row[col.key];
+        const formatted = formatCellValue(value);
+        return formatted.length;
+      }),
+    );
+
+    return Math.min(Math.max(headerWidth, maxContentWidth), 50);
+  });
+}
+
+/**
+ * Get column formatter based on field type
+ */
+export function getColumnFormatter(
+  type: FieldDataType,
+  locale: CountryLanguage,
+): (value: WidgetData) => string {
+  switch (type) {
+    case FieldDataType.NUMBER:
+      return (value) => {
+        if (typeof value === "number") {
+          return value.toLocaleString(locale);
+        }
+        return formatCellValue(value);
+      };
+    case FieldDataType.BOOLEAN:
+      return (value) => {
+        if (typeof value === "boolean") {
+          return value ? "✓" : "✗";
+        }
+        return formatCellValue(value);
+      };
+    case FieldDataType.DATE:
+      return (value) => {
+        if (typeof value === "string" || value instanceof Date) {
+          const date = value instanceof Date ? value : new Date(value);
+          return date.toLocaleDateString(locale);
+        }
+        return formatCellValue(value);
+      };
+    case FieldDataType.ARRAY:
+      return (value) => {
+        if (Array.isArray(value)) {
+          return `[${value.length} items]`;
+        }
+        return formatCellValue(value);
+      };
+    case FieldDataType.OBJECT:
+      return (value) => {
+        if (
+          typeof value === "object" &&
+          value !== null &&
+          !Array.isArray(value)
+        ) {
+          return `{${Object.keys(value).length} properties}`;
+        }
+        return formatCellValue(value);
+      };
+    default:
+      return (value) => {
+        const str = formatCellValue(value);
+        return str.length > 50 ? `${str.slice(0, 47)}...` : str;
+      };
+  }
+}
+
+/**
+ * Format cell value as string for display
+ */
+export function formatCellValue(value: WidgetData): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return "";
+}

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

@@ -0,0 +1,89 @@
+/**
+ * Editable Text Widget Logic
+ * Shared data extraction and processing for EDITABLE_TEXT widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Processed editable text data structure
+ */
+export interface ProcessedEditableText {
+  value: string;
+  placeholder?: string;
+  multiline?: boolean;
+  maxLength?: number;
+  readonly?: boolean;
+}
+
+/**
+ * Extract and validate editable text data from WidgetData
+ */
+export function extractEditableTextData(
+  value: WidgetData,
+): ProcessedEditableText | null {
+  // Handle string value directly
+  if (typeof value === "string") {
+    return {
+      value,
+      multiline: false,
+      readonly: false,
+    };
+  }
+
+  // Handle number value
+  if (typeof value === "number") {
+    return {
+      value: String(value),
+      multiline: false,
+      readonly: false,
+    };
+  }
+
+  // Handle object value with editable text properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const textValue =
+      "value" in value && typeof value.value === "string"
+        ? value.value
+        : "value" in value && typeof value.value === "number"
+          ? String(value.value)
+          : "";
+    const placeholder =
+      "placeholder" in value && typeof value.placeholder === "string"
+        ? value.placeholder
+        : undefined;
+    const multiline =
+      "multiline" in value && typeof value.multiline === "boolean"
+        ? value.multiline
+        : false;
+    const maxLength =
+      "maxLength" in value && typeof value.maxLength === "number"
+        ? value.maxLength
+        : undefined;
+    const readonly =
+      "readonly" in value && typeof value.readonly === "boolean"
+        ? value.readonly
+        : false;
+
+    return {
+      value: textValue,
+      placeholder,
+      multiline,
+      maxLength,
+      readonly,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Validate text length
+ */
+export function isValidTextLength(text: string, maxLength?: number): boolean {
+  if (!maxLength) {
+    return true;
+  }
+  return text.length <= maxLength;
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Empty State Widget Logic
+ * Shared data extraction and processing for EMPTY_STATE widget
+ * Used by both React and CLI implementations
+ */
+
+import type { WidgetData } from "../types";
+
+/**
+ * Processed empty state data structure
+ */
+export interface ProcessedEmptyState {
+  title: string;
+  description?: string;
+  icon?: string;
+  action?: {
+    label: string;
+    action: string;
+  };
+}
+
+/**
+ * Extract and validate empty state data from WidgetData
+ */
+export function extractEmptyStateData(
+  value: WidgetData,
+): ProcessedEmptyState | null {
+  // Handle string value directly (simple message)
+  if (typeof value === "string") {
+    return {
+      title: value,
+    };
+  }
+
+  // Handle object value with empty state properties
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const title =
+      "title" in value && typeof value.title === "string"
+        ? value.title
+        : "No data";
+    const description =
+      "description" in value && typeof value.description === "string"
+        ? value.description
+        : undefined;
+    const icon =
+      "icon" in value && typeof value.icon === "string"
+        ? value.icon
+        : undefined;
+    const action =
+      "action" in value &&
+      typeof value.action === "object" &&
+      value.action !== null
+        ? {
+            label:
+              "label" in value.action && typeof value.action.label === "string"
+                ? value.action.label
+                : "Action",
+            action:
+              "action" in value.action &&
+              typeof value.action.action === "string"
+                ? value.action.action
+                : "",
+          }
+        : undefined;
+
+    return {
+      title,
+      description,
+      icon,
+      action,
+    };
+  }
+
+  // Default empty state
+  return {
+    title: "No data",
+  };
+}