torch-glare 2.4.0 → 2.4.1

package/apps/lib/utils/dataViews/nestedDataUtils.tsx

@@ -1,24 +1,26 @@
-import type { ReactElement } from "react"
-import { Badge } from "../../components/Badge"
-import { Divider } from "../../components/Divider"
-import { cn } from "../cn"
-import type { DynamicRecord, DynamicColumnConfig } from "../../components/DataViews/types"
+import type { ReactElement } from "react";
+import { Badge } from "../../components/Badge";
+import { Divider } from "../../components/Divider";
+import { cn } from "../cn";
+import type { DynamicRecord, DynamicColumnConfig } from "../../components/DataViews/types";
 
 export type NestedFieldMetadata = {
-  key: string
-  label: string
-  type: 'object' | 'array' | 'primitive'
-  valueType?: 'string' | 'number' | 'boolean' | 'date'
-  isArrayOfObjects?: boolean
-  depth: number
-}
-
-export function isPlainObject(value: any): boolean {
-  return value !== null &&
-         typeof value === 'object' &&
-         !Array.isArray(value) &&
-         !(value instanceof Date) &&
-         Object.keys(value).length > 0
+  key: string;
+  label: string;
+  type: "object" | "array" | "primitive";
+  valueType?: "string" | "number" | "boolean" | "date";
+  isArrayOfObjects?: boolean;
+  depth: number;
+};
+
+export function isPlainObject(value: unknown): boolean {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    !(value instanceof Date) &&
+    Object.keys(value).length > 0
+  );
 }
 
 export function formatFieldName(fieldName: string): string {
@@ -26,84 +28,85 @@ export function formatFieldName(fieldName: string): string {
     return fieldName
       .split("_")
       .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(" ")
+      .join(" ");
   }
 
   return fieldName
     .replace(/([A-Z])/g, " $1")
     .replace(/^./, (str) => str.toUpperCase())
-    .trim()
+    .trim();
 }
 
 export function analyzeNestedFields(
   item: DynamicRecord,
   visibleColumnIds: Set<string> = new Set(),
-  excludeKeys: string[] = ['id', 'isRead', 'isStarred', 'hasAttachment', 'priority']
+  excludeKeys: string[] = ["id", "isRead", "isStarred", "hasAttachment", "priority"],
 ): NestedFieldMetadata[] {
-  const nestedFields: NestedFieldMetadata[] = []
+  const nestedFields: NestedFieldMetadata[] = [];
 
   Object.entries(item).forEach(([key, value]) => {
     if (visibleColumnIds.has(key) || excludeKeys.includes(key)) {
-      return
+      return;
     }
 
     if (isPlainObject(value)) {
       nestedFields.push({
         key,
         label: formatFieldName(key),
-        type: 'object',
-        depth: 0
-      })
+        type: "object",
+        depth: 0,
+      });
     } else if (Array.isArray(value) && value.length > 0) {
       nestedFields.push({
         key,
         label: formatFieldName(key),
-        type: 'array',
+        type: "array",
         isArrayOfObjects: isPlainObject(value[0]),
-        depth: 0
-      })
+        depth: 0,
+      });
     }
-  })
+  });
 
-  return nestedFields
+  return nestedFields;
 }
 
 export function isCurrencyField(key: string): boolean {
-  const lowerKey = key.toLowerCase()
-  return lowerKey.includes('salary') ||
-         lowerKey.includes('price') ||
-         lowerKey.includes('cost') ||
-         lowerKey.includes('amount') ||
-         lowerKey.includes('pay') ||
-         lowerKey.includes('fee')
+  const lowerKey = key.toLowerCase();
+  return (
+    lowerKey.includes("salary") ||
+    lowerKey.includes("price") ||
+    lowerKey.includes("cost") ||
+    lowerKey.includes("amount") ||
+    lowerKey.includes("pay") ||
+    lowerKey.includes("fee")
+  );
 }
 
 export function isRatingField(key: string): boolean {
-  const lowerKey = key.toLowerCase()
-  return lowerKey.includes('rating') ||
-         lowerKey.includes('score')
+  const lowerKey = key.toLowerCase();
+  return lowerKey.includes("rating") || lowerKey.includes("score");
 }
 
 export function renderPrimitiveValue(
   key: string,
-  value: any,
+  value: unknown,
   options: {
-    showLabel?: boolean
-    labelClassName?: string
-    valueClassName?: string
-  } = {}
+    showLabel?: boolean;
+    labelClassName?: string;
+    valueClassName?: string;
+  } = {},
 ): ReactElement | null {
   const {
     showLabel = true,
     labelClassName = "text-content-presentation-global-tertiary",
-    valueClassName = "text-content-presentation-global-primary"
-  } = options
+    valueClassName = "text-content-presentation-global-primary",
+  } = options;
 
-  if (value == null) return null
+  if (value == null) return null;
 
-  const label = showLabel ? formatFieldName(key) : null
+  const label = showLabel ? formatFieldName(key) : null;
 
-  if (typeof value === 'boolean') {
+  if (typeof value === "boolean") {
     return (
       <div className="flex items-center gap-2">
         {label && <span className={labelClassName}>{label}:</span>}
@@ -112,15 +115,14 @@ export function renderPrimitiveValue(
           badgeStyle={value ? "solid" : "subtle"}
           label={value ? "Yes" : "No"}
           size="XS"
-         
         />
       </div>
-    )
+    );
   }
 
-  if (typeof value === 'number') {
-    const isCurrency = isCurrencyField(key)
-    const isRating = isRatingField(key)
+  if (typeof value === "number") {
+    const isCurrency = isCurrencyField(key);
+    const isRating = isRatingField(key);
 
     if (isRating && value <= 5) {
       return (
@@ -129,7 +131,10 @@ export function renderPrimitiveValue(
           <div className="flex items-center gap-2">
             <div className="flex">
               {[...Array(5)].map((_, i) => (
-                <span key={i} className={i < Math.floor(value) ? 'text-yellow-500' : 'text-gray-300'}>
+                <span
+                  key={i}
+                  className={i < Math.floor(value) ? "text-yellow-500" : "text-gray-300"}
+                >
                   ⭐
                 </span>
               ))}
@@ -137,20 +142,17 @@ export function renderPrimitiveValue(
             <span className="font-semibold text-sm">{value}</span>
           </div>
         </div>
-      )
+      );
     }
 
     return (
       <div className="flex items-center gap-2">
         {label && <span className={labelClassName}>{label}:</span>}
-        <span className={cn(
-          valueClassName,
-          isCurrency && "font-semibold text-green-600"
-        )}>
+        <span className={cn(valueClassName, isCurrency && "font-semibold text-green-600")}>
           {isCurrency ? `$${value.toLocaleString()}` : value.toLocaleString()}
         </span>
       </div>
-    )
+    );
   }
 
   return (
@@ -158,24 +160,24 @@ export function renderPrimitiveValue(
       {label && <span className={labelClassName}>{label}:</span>}
       <span className={valueClassName}>{String(value)}</span>
     </div>
-  )
+  );
 }
 
 export function renderArrayValue(
   key: string,
-  value: any[],
+  value: unknown[],
   options: {
-    showLabel?: boolean
-    maxItems?: number
-    renderItem?: (item: any, index: number) => ReactElement
-  } = {}
+    showLabel?: boolean;
+    maxItems?: number;
+    renderItem?: (item: unknown, index: number) => ReactElement;
+  } = {},
 ): ReactElement | null {
-  const { showLabel = true, maxItems, renderItem } = options
+  const { showLabel = true, maxItems, renderItem } = options;
 
-  if (!Array.isArray(value) || value.length === 0) return null
+  if (!Array.isArray(value) || value.length === 0) return null;
 
-  const label = showLabel ? formatFieldName(key) : null
-  const displayItems = maxItems ? value.slice(0, maxItems) : value
+  const label = showLabel ? formatFieldName(key) : null;
+  const displayItems = maxItems ? value.slice(0, maxItems) : value;
 
   if (isPlainObject(value[0])) {
     return (
@@ -186,15 +188,15 @@ export function renderArrayValue(
           </div>
         )}
         <div className="space-y-2">
-          {displayItems.map((item: any, idx: number) => {
+          {displayItems.map((item: unknown, idx: number) => {
             if (renderItem) {
-              return renderItem(item, idx)
+              return renderItem(item, idx);
             }
             return (
               <div key={idx} className="p-2 rounded bg-background-presentation-form-field-primary">
                 {renderNestedObject(item, 1)}
               </div>
-            )
+            );
           })}
           {maxItems && value.length > maxItems && (
             <div className="text-xs text-content-presentation-global-tertiary">
@@ -203,14 +205,14 @@ export function renderArrayValue(
           )}
         </div>
       </div>
-    )
+    );
   }
 
   return (
     <div className="flex items-start gap-2">
       {label && <span className="text-content-presentation-global-tertiary">{label}:</span>}
       <div className="flex flex-wrap gap-1">
-        {displayItems.map((item: any, idx: number) => (
+        {displayItems.map((item: unknown, idx: number) => (
           <Badge key={idx} color="blue" badgeStyle="solid" label={String(item)} size="XS" />
         ))}
         {maxItems && value.length > maxItems && (
@@ -218,26 +220,26 @@ export function renderArrayValue(
         )}
       </div>
     </div>
-  )
+  );
 }
 
 export function renderNestedObject(
-  obj: any,
+  obj: unknown,
   depth: number = 0,
   options: {
-    maxDepth?: number
-    showSeparators?: boolean
-  } = {}
+    maxDepth?: number;
+    showSeparators?: boolean;
+  } = {},
 ): ReactElement {
-  const { maxDepth = 3 } = options
+  const { maxDepth = 3 } = options;
 
   if (depth >= maxDepth) {
-    return <div className="text-xs text-content-presentation-global-tertiary">...</div>
+    return <div className="text-xs text-content-presentation-global-tertiary">...</div>;
   }
 
   return (
     <div className="space-y-2 text-sm">
-      {Object.entries(obj).map(([key, value]) => {
+      {Object.entries(obj as Record<string, unknown>).map(([key, value]) => {
         if (isPlainObject(value)) {
           return (
             <div key={key} className="space-y-1">
@@ -248,34 +250,39 @@ export function renderNestedObject(
                 {renderNestedObject(value, depth + 1, options)}
               </div>
             </div>
-          )
+          );
         }
 
         if (Array.isArray(value)) {
-          return <div key={key}>{renderArrayValue(key, value)}</div>
+          return <div key={key}>{renderArrayValue(key, value)}</div>;
         }
 
-        return <div key={key}>{renderPrimitiveValue(key, value)}</div>
+        return <div key={key}>{renderPrimitiveValue(key, value)}</div>;
       })}
     </div>
-  )
+  );
 }
 
 export function renderDetailView(
   selectedItem: DynamicRecord,
   visibleColumns: DynamicColumnConfig[],
-  renderCellValue: (value: any, column: DynamicColumnConfig, row: DynamicRecord) => React.ReactNode
+  renderCellValue: (
+    value: unknown,
+    column: DynamicColumnConfig,
+    row: DynamicRecord,
+  ) => React.ReactNode,
 ): ReactElement {
-  const visibleColumnIds = new Set(visibleColumns.map(col => col.id))
-  const nestedFields = analyzeNestedFields(selectedItem, visibleColumnIds)
+  const visibleColumnIds = new Set(visibleColumns.map((col) => col.id));
+  const nestedFields = analyzeNestedFields(selectedItem, visibleColumnIds);
 
   return (
     <div className="space-y-6">
       {visibleColumns.slice(2).length > 0 && (
         <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
           {visibleColumns.slice(2).map((col) => {
-            const value = selectedItem[col.id]
-            if (value == null && value !== 0 && value !== false) return null
+            const value = selectedItem[col.id];
+            // Skip empty cells (null/undefined); 0 and false are rendered.
+            if (value === null || value === undefined) return null;
             return (
               <div key={col.id} className="space-y-1">
                 <dt className="text-xs font-medium text-content-presentation-global-tertiary uppercase tracking-wide">
@@ -285,15 +292,15 @@ export function renderDetailView(
                   {renderCellValue(value, col, selectedItem)}
                 </dd>
               </div>
-            )
+            );
           })}
         </div>
       )}
 
       {nestedFields.map((field, index) => {
-        const value = selectedItem[field.key]
+        const value = selectedItem[field.key];
 
-        if (field.type === 'object' && isPlainObject(value)) {
+        if (field.type === "object" && isPlainObject(value)) {
           return (
             <div key={field.key}>
               {index > 0 && <Divider />}
@@ -304,10 +311,10 @@ export function renderDetailView(
                 {renderNestedObject(value)}
               </div>
             </div>
-          )
+          );
         }
 
-        if (field.type === 'array' && Array.isArray(value)) {
+        if (field.type === "array" && Array.isArray(value)) {
           return (
             <div key={field.key}>
               {index > 0 && <Divider />}
@@ -318,47 +325,47 @@ export function renderDetailView(
                 {renderArrayValue(field.key, value, { showLabel: false })}
               </div>
             </div>
-          )
+          );
         }
 
-        return null
+        return null;
       })}
     </div>
-  )
+  );
 }
 
 export function getDataStructureSummary(data: DynamicRecord[]): {
-  totalFields: number
-  nestedFields: string[]
-  arrayFields: string[]
-  primitiveFields: string[]
+  totalFields: number;
+  nestedFields: string[];
+  arrayFields: string[];
+  primitiveFields: string[];
 } {
   if (!data || data.length === 0) {
-    return { totalFields: 0, nestedFields: [], arrayFields: [], primitiveFields: [] }
+    return { totalFields: 0, nestedFields: [], arrayFields: [], primitiveFields: [] };
   }
 
-  const allKeys = new Set<string>()
-  const nestedKeys = new Set<string>()
-  const arrayKeys = new Set<string>()
-  const primitiveKeys = new Set<string>()
+  const allKeys = new Set<string>();
+  const nestedKeys = new Set<string>();
+  const arrayKeys = new Set<string>();
+  const primitiveKeys = new Set<string>();
 
-  data.forEach(item => {
+  data.forEach((item) => {
     Object.entries(item).forEach(([key, value]) => {
-      allKeys.add(key)
+      allKeys.add(key);
       if (isPlainObject(value)) {
-        nestedKeys.add(key)
+        nestedKeys.add(key);
       } else if (Array.isArray(value)) {
-        arrayKeys.add(key)
+        arrayKeys.add(key);
       } else {
-        primitiveKeys.add(key)
+        primitiveKeys.add(key);
       }
-    })
-  })
+    });
+  });
 
   return {
     totalFields: allKeys.size,
     nestedFields: Array.from(nestedKeys),
     arrayFields: Array.from(arrayKeys),
-    primitiveFields: Array.from(primitiveKeys)
-  }
+    primitiveFields: Array.from(primitiveKeys),
+  };
 }

package/apps/lib/utils/dataViews/pathUtils.ts

@@ -1,132 +1,139 @@
-export type Path = string
+export type Path = string;
 
-const PATH_CACHE = new Map<string, string[]>()
+const PATH_CACHE = new Map<string, string[]>();
 
 function splitPath(path: Path): string[] {
-  const cached = PATH_CACHE.get(path)
-  if (cached) return cached
-  const parts = path.split(".")
-  PATH_CACHE.set(path, parts)
-  return parts
+  const cached = PATH_CACHE.get(path);
+  if (cached) return cached;
+  const parts = path.split(".");
+  PATH_CACHE.set(path, parts);
+  return parts;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- generic path accessor returns arbitrary runtime values
 export function getByPath(obj: unknown, path: Path | undefined | null): any {
-  if (obj == null || path == null || path === "") return undefined
-  if (typeof obj !== "object") return undefined
+  if (obj == null || path == null || path === "") return undefined;
+  if (typeof obj !== "object") return undefined;
 
-  const parts = splitPath(path)
-  let cur: any = obj
+  const parts = splitPath(path);
+  let cur: unknown = obj;
   for (let i = 0; i < parts.length; i++) {
-    if (cur == null) return undefined
-    cur = cur[parts[i]]
+    if (cur == null) return undefined;
+    cur = (cur as Record<string, unknown>)[parts[i]];
   }
-  return cur
+  return cur;
 }
 
-export function setByPath<T extends Record<string, any>>(
+export function setByPath<T extends Record<string, unknown>>(
   obj: T,
   path: Path,
-  value: any,
+  value: unknown,
 ): T {
-  if (!path) return obj
-  const parts = splitPath(path)
-  if (parts.length === 0) return obj
+  if (!path) return obj;
+  const parts = splitPath(path);
+  if (parts.length === 0) return obj;
 
-  const root: any = Array.isArray(obj) ? [...obj] : { ...obj }
-  let cur: any = root
+  const root = (Array.isArray(obj) ? [...obj] : { ...obj }) as Record<string, unknown>;
+  let cur: Record<string, unknown> = root;
 
   for (let i = 0; i < parts.length - 1; i++) {
-    const key = parts[i]
-    const next = cur[key]
-    const cloned = next != null && typeof next === "object" && !Array.isArray(next)
-      ? { ...next }
-      : Array.isArray(next)
-        ? [...next]
-        : {}
-    cur[key] = cloned
-    cur = cloned
+    const key = parts[i];
+    const next = cur[key];
+    const cloned = (
+      next != null && typeof next === "object" && !Array.isArray(next)
+        ? { ...next }
+        : Array.isArray(next)
+          ? [...next]
+          : {}
+    ) as Record<string, unknown>;
+    cur[key] = cloned;
+    cur = cloned;
   }
 
-  cur[parts[parts.length - 1]] = value
-  return root
+  cur[parts[parts.length - 1]] = value;
+  return root as T;
 }
 
 export function hasPath(obj: unknown, path: Path | undefined | null): boolean {
-  return getByPath(obj, path) !== undefined
+  return getByPath(obj, path) !== undefined;
 }
 
 export function formatPathLabel(path: Path): string {
-  if (!path) return ""
-  const tail = path.includes(".") ? path.split(".").pop()! : path
+  if (!path) return "";
+  const tail = path.includes(".") ? path.split(".").pop()! : path;
 
   if (tail.includes("_")) {
     return tail
       .split("_")
       .filter(Boolean)
       .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-      .join(" ")
+      .join(" ");
   }
 
   return tail
     .replace(/([A-Z])/g, " $1")
     .replace(/^./, (s) => s.toUpperCase())
-    .trim()
+    .trim();
 }
 
-export function findFirstDefined(data: any[], path: Path): any {
+export function findFirstDefined(data: unknown[], path: Path): unknown {
   for (const item of data) {
-    const v = getByPath(item, path)
-    if (v != null) return v
+    const v = getByPath(item, path);
+    if (v != null) return v;
   }
-  return undefined
+  return undefined;
 }
 
 export function matchesFilterValues(
   item: unknown,
   path: Path,
-  filter: string[] | { kind: "number"; min?: number; max?: number } | { kind: "date"; from?: string; to?: string } | undefined,
+  filter:
+    | string[]
+    | { kind: "number"; min?: number; max?: number }
+    | { kind: "date"; from?: string; to?: string }
+    | undefined,
 ): boolean {
-  if (filter == null) return true
+  if (filter == null) return true;
 
   if (Array.isArray(filter)) {
-    if (filter.length === 0) return true
-    const value = getByPath(item, path)
+    if (filter.length === 0) return true;
+    const value = getByPath(item, path);
     if (Array.isArray(value)) {
-      const set = new Set(value.map((v) => String(v)))
-      return filter.some((s) => set.has(s))
+      const set = new Set(value.map((v) => String(v)));
+      return filter.some((s) => set.has(s));
     }
     if (typeof value === "boolean") {
-      return filter.includes(value ? "true" : "false")
+      return filter.includes(value ? "true" : "false");
     }
-    return filter.includes(String(value ?? ""))
+    return filter.includes(String(value ?? ""));
   }
 
   if (filter.kind === "number") {
-    if (filter.min == null && filter.max == null) return true
-    const raw = getByPath(item, path)
-    const n = typeof raw === "number" ? raw : Number(raw)
-    if (!Number.isFinite(n)) return false
-    if (filter.min != null && n < filter.min) return false
-    if (filter.max != null && n > filter.max) return false
-    return true
+    if (filter.min == null && filter.max == null) return true;
+    const raw = getByPath(item, path);
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n)) return false;
+    if (filter.min != null && n < filter.min) return false;
+    if (filter.max != null && n > filter.max) return false;
+    return true;
   }
 
   if (filter.kind === "date") {
-    if (filter.from == null && filter.to == null) return true
-    const raw = getByPath(item, path)
-    if (raw == null) return false
-    const ms = raw instanceof Date ? raw.getTime() : Date.parse(String(raw))
-    if (!Number.isFinite(ms)) return false
+    if (filter.from == null && filter.to == null) return true;
+    const raw = getByPath(item, path);
+    if (raw == null) return false;
+    const ms = raw instanceof Date ? raw.getTime() : Date.parse(String(raw));
+    if (!Number.isFinite(ms)) return false;
     if (filter.from != null) {
-      const fromMs = Date.parse(filter.from)
-      if (Number.isFinite(fromMs) && ms < fromMs) return false
+      const fromMs = Date.parse(filter.from);
+      if (Number.isFinite(fromMs) && ms < fromMs) return false;
     }
     if (filter.to != null) {
-      const toMs = Date.parse(filter.to)
-      if (Number.isFinite(toMs) && ms > toMs + 24 * 60 * 60 * 1000 - 1) return false
+      const toMs = Date.parse(filter.to);
+      if (Number.isFinite(toMs) && ms > toMs + 24 * 60 * 60 * 1000 - 1) return false;
     }
-    return true
+    return true;
   }
 
-  return true
+  return true;
 }