torch-glare 2.3.0 → 2.4.1

package/apps/lib/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": []
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}

package/apps/lib/utils/cn.ts

@@ -2,5 +2,5 @@ import { clsx, type ClassValue } from "clsx";
 import { twMerge } from "tailwind-merge";
 
 export function cn(...inputs: ClassValue[]) {
-    return twMerge(clsx(inputs));
+  return twMerge(clsx(inputs));
 }

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

@@ -1,28 +1,28 @@
-import type { DynamicColumnConfig, DynamicRecord } from "../../components/DataViews/types"
-import { isPlainObject } from "./nestedDataUtils"
+import type { DynamicColumnConfig, DynamicRecord } from "../../components/DataViews/types";
+import { isPlainObject } from "./nestedDataUtils";
 
 export function detectColumns(data: DynamicRecord[]): DynamicColumnConfig[] {
   if (!data || data.length === 0) {
-    return []
+    return [];
   }
 
-  const allKeys = new Set<string>()
+  const allKeys = new Set<string>();
   data.forEach((item) => {
-    Object.keys(item).forEach((key) => allKeys.add(key))
-  })
+    Object.keys(item).forEach((key) => allKeys.add(key));
+  });
 
-  const columns: DynamicColumnConfig[] = []
-  let order = 0
+  const columns: DynamicColumnConfig[] = [];
+  let order = 0;
 
   allKeys.forEach((key) => {
-    if (key.startsWith("_")) return
+    if (key.startsWith("_")) return;
 
-    const firstValue = data.find((item) => item[key] != null)?.[key]
+    const firstValue = data.find((item) => item[key] != null)?.[key];
 
-    if (isPlainObject(firstValue)) return
-    if (Array.isArray(firstValue) && firstValue.length > 0 && isPlainObject(firstValue[0])) return
+    if (isPlainObject(firstValue)) return;
+    if (Array.isArray(firstValue) && firstValue.length > 0 && isPlainObject(firstValue[0])) return;
 
-    const type = inferColumnType(key, firstValue)
+    const type = inferColumnType(key, firstValue);
 
     columns.push({
       id: key,
@@ -30,54 +30,56 @@ export function detectColumns(data: DynamicRecord[]): DynamicColumnConfig[] {
       visible: true,
       order: order++,
       type,
+    });
+  });
+
+  return columns
+    .sort((a, b) => {
+      if (a.id === "id") return -1;
+      if (b.id === "id") return 1;
+      return a.label.localeCompare(b.label);
     })
-  })
-
-  return columns.sort((a, b) => {
-    if (a.id === "id") return -1
-    if (b.id === "id") return 1
-    return a.label.localeCompare(b.label)
-  }).map((col, idx) => ({ ...col, order: idx }))
+    .map((col, idx) => ({ ...col, order: idx }));
 }
 
 function inferColumnType(
   key: string,
-  value: any
+  value: unknown,
 ): "text" | "number" | "date" | "badge" | "array" | "boolean" {
   if (key.toLowerCase().includes("date") || key.toLowerCase().includes("time")) {
-    return "date"
+    return "date";
   }
   if (key.toLowerCase().includes("status") || key.toLowerCase().includes("priority")) {
-    return "badge"
+    return "badge";
   }
   if (key.toLowerCase().includes("tag") || key.toLowerCase().includes("label")) {
-    return "array"
+    return "array";
   }
 
   if (value === null || value === undefined) {
-    return "text"
+    return "text";
   }
 
   if (typeof value === "boolean") {
-    return "boolean"
+    return "boolean";
   }
 
   if (typeof value === "number") {
-    return "number"
+    return "number";
   }
 
   if (Array.isArray(value)) {
-    return "array"
+    return "array";
   }
 
   if (typeof value === "string") {
     if (!isNaN(Date.parse(value)) && /^\d{4}-\d{2}-\d{2}/.test(value)) {
-      return "date"
+      return "date";
     }
-    return "text"
+    return "text";
   }
 
-  return "text"
+  return "text";
 }
 
 function formatLabel(key: string): string {
@@ -85,33 +87,33 @@ function formatLabel(key: string): string {
     return key
       .split("_")
       .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(" ")
+      .join(" ");
   }
 
   return key
     .replace(/([A-Z])/g, " $1")
     .replace(/^./, (str) => str.toUpperCase())
-    .trim()
+    .trim();
 }
 
 export function mergeColumns(
   detected: DynamicColumnConfig[],
-  custom?: Partial<DynamicColumnConfig>[]
+  custom?: Partial<DynamicColumnConfig>[],
 ): DynamicColumnConfig[] {
   if (!custom || custom.length === 0) {
-    return detected
+    return detected;
   }
 
-  const merged = [...detected]
-  const customMap = new Map(custom.map((col) => [col.id, col]))
+  const merged = [...detected];
+  const customMap = new Map(custom.map((col) => [col.id, col]));
 
   merged.forEach((col, idx) => {
-    const customCol = customMap.get(col.id)
+    const customCol = customMap.get(col.id);
     if (customCol) {
-      merged[idx] = { ...col, ...customCol }
-      customMap.delete(col.id)
+      merged[idx] = { ...col, ...customCol };
+      customMap.delete(col.id);
     }
-  })
+  });
 
   customMap.forEach((customCol) => {
     if (customCol.id) {
@@ -122,9 +124,9 @@ export function mergeColumns(
         order: customCol.order ?? merged.length,
         type: customCol.type || "text",
         render: customCol.render,
-      })
+      });
     }
-  })
+  });
 
-  return merged.sort((a, b) => a.order - b.order)
+  return merged.sort((a, b) => a.order - b.order);
 }

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

@@ -4,11 +4,11 @@ import type {
   FieldType,
   DynamicColumnConfig,
   InboxConfig,
-} from "../../components/DataViews/types"
-import { findFirstDefined, formatPathLabel, getByPath } from "./pathUtils"
-import { isPlainObject, isCurrencyField, isRatingField } from "./nestedDataUtils"
+} from "../../components/DataViews/types";
+import { findFirstDefined, formatPathLabel, getByPath } from "./pathUtils";
+import { isPlainObject, isCurrencyField, isRatingField } from "./nestedDataUtils";
 
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}/
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}/;
 
 const KEY_HINTS: Array<[RegExp, FieldType]> = [
   [/(^|[._])status$/i, "enum-badge"],
@@ -20,46 +20,46 @@ const KEY_HINTS: Array<[RegExp, FieldType]> = [
   [/(^|[._])(image|thumbnail|photo|picture)$/i, "image"],
   [/(^|[._])tags?$|labels?$/i, "badge-array"],
   [/(date|time)$/i, "date-format"],
-]
+];
 
-export function inferFieldType(path: string, value: any): FieldType {
+export function inferFieldType(path: string, value: unknown): FieldType {
   for (const [re, type] of KEY_HINTS) {
-    if (re.test(path)) return type
+    if (re.test(path)) return type;
   }
 
-  if (isCurrencyField(path)) return "currency"
-  if (isRatingField(path) && typeof value === "number" && value <= 5) return "star-rating"
+  if (isCurrencyField(path)) return "currency";
+  if (isRatingField(path) && typeof value === "number" && value <= 5) return "star-rating";
 
-  if (value === null || value === undefined) return "text"
-  if (typeof value === "boolean") return "boolean"
-  if (typeof value === "number") return "number"
-  if (Array.isArray(value)) return "badge-array"
+  if (value === null || value === undefined) return "text";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  if (Array.isArray(value)) return "badge-array";
   if (typeof value === "string") {
-    if (ISO_DATE.test(value) && !isNaN(Date.parse(value))) return "date-format"
-    return "text"
+    if (ISO_DATE.test(value) && !isNaN(Date.parse(value))) return "date-format";
+    return "text";
   }
-  return "text"
+  return "text";
 }
 
 export function detectFields(data: DynamicRecord[]): FieldConfig[] {
-  if (!data || data.length === 0) return []
+  if (!data || data.length === 0) return [];
 
-  const allKeys = new Set<string>()
+  const allKeys = new Set<string>();
   for (const item of data) {
     if (item && typeof item === "object") {
-      for (const k of Object.keys(item)) allKeys.add(k)
+      for (const k of Object.keys(item)) allKeys.add(k);
     }
   }
 
-  const fields: FieldConfig[] = []
-  let order = 0
+  const fields: FieldConfig[] = [];
+  let order = 0;
 
   for (const key of allKeys) {
-    if (key.startsWith("_")) continue
+    if (key.startsWith("_")) continue;
 
-    const sample = findFirstDefined(data, key)
-    if (isPlainObject(sample)) continue
-    if (Array.isArray(sample) && sample.length > 0 && isPlainObject(sample[0])) continue
+    const sample = findFirstDefined(data, key);
+    if (isPlainObject(sample)) continue;
+    if (Array.isArray(sample) && sample.length > 0 && isPlainObject(sample[0])) continue;
 
     fields.push({
       path: key,
@@ -67,32 +67,29 @@ export function detectFields(data: DynamicRecord[]): FieldConfig[] {
       type: inferFieldType(key, sample),
       visible: true,
       order: order++,
-    })
+    });
   }
 
   return fields
     .sort((a, b) => {
-      if (a.path === "id") return -1
-      if (b.path === "id") return 1
-      return (a.label || "").localeCompare(b.label || "")
+      if (a.path === "id") return -1;
+      if (b.path === "id") return 1;
+      return (a.label || "").localeCompare(b.label || "");
     })
-    .map((f, i) => ({ ...f, order: i }))
+    .map((f, i) => ({ ...f, order: i }));
 }
 
-export function mergeFields(
-  detected: FieldConfig[],
-  custom?: FieldConfig[],
-): FieldConfig[] {
-  if (!custom || custom.length === 0) return detected
+export function mergeFields(detected: FieldConfig[], custom?: FieldConfig[]): FieldConfig[] {
+  if (!custom || custom.length === 0) return detected;
 
-  const out = [...detected]
-  const byPath = new Map(out.map((f, i) => [f.path, i]))
+  const out = [...detected];
+  const byPath = new Map(out.map((f, i) => [f.path, i]));
 
   for (const c of custom) {
-    if (!c.path) continue
-    const existing = byPath.get(c.path)
+    if (!c.path) continue;
+    const existing = byPath.get(c.path);
     if (existing != null) {
-      out[existing] = { ...out[existing], ...c }
+      out[existing] = { ...out[existing], ...c };
     } else {
       out.push({
         ...c,
@@ -100,24 +97,27 @@ export function mergeFields(
         label: c.label ?? formatPathLabel(c.path),
         visible: c.visible ?? true,
         order: c.order ?? out.length,
-      })
-      byPath.set(c.path, out.length - 1)
+      });
+      byPath.set(c.path, out.length - 1);
     }
   }
 
   return out
     .map((f, i) => ({ ...f, order: f.order ?? i }))
-    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
 }
 
 export function visibleFields(fields: FieldConfig[]): FieldConfig[] {
-  return fields.filter((f) => f.type !== "hidden" && f.visible !== false)
+  return fields.filter((f) => f.type !== "hidden" && f.visible !== false);
 }
 
-export function fieldToColumn(field: FieldConfig, idx = 0): DynamicColumnConfig & {
-  __field: FieldConfig
+export function fieldToColumn(
+  field: FieldConfig,
+  idx = 0,
+): DynamicColumnConfig & {
+  __field: FieldConfig;
 } {
-  const legacyType = mapFieldTypeToColumnType(field.type)
+  const legacyType = mapFieldTypeToColumnType(field.type);
   return {
     id: field.path,
     label: field.label ?? formatPathLabel(field.path),
@@ -126,7 +126,7 @@ export function fieldToColumn(field: FieldConfig, idx = 0): DynamicColumnConfig
     type: legacyType,
     render: field.render,
     __field: field,
-  }
+  };
 }
 
 function mapFieldTypeToColumnType(t?: FieldType): DynamicColumnConfig["type"] {
@@ -136,63 +136,62 @@ function mapFieldTypeToColumnType(t?: FieldType): DynamicColumnConfig["type"] {
     case "number-format":
     case "progress-bar":
     case "star-rating":
-      return "number"
+      return "number";
     case "date":
     case "date-format":
-      return "date"
+      return "date";
     case "enum-badge":
     case "icon-text":
     case "two-line":
     case "link":
-      return "badge"
+      return "badge";
     case "badge-array":
-      return "array"
+      return "array";
     case "boolean":
-      return "boolean"
+      return "boolean";
     default:
-      return "text"
+      return "text";
   }
 }
 
-const STARRED_PATTERNS = ["isStarred", "starred", "favorite", "isFavorite", "pinned"]
-const READ_PATTERNS = ["isRead", "read", "seen", "viewed"]
-const ATTACHMENT_PATTERNS = ["hasAttachment", "hasAttachments", "attachments", "files"]
-const PRIORITY_PATTERNS = ["priority", "urgency", "level", "importance"]
+const STARRED_PATTERNS = ["isStarred", "starred", "favorite", "isFavorite", "pinned"];
+const READ_PATTERNS = ["isRead", "read", "seen", "viewed"];
+const ATTACHMENT_PATTERNS = ["hasAttachment", "hasAttachments", "attachments", "files"];
+const PRIORITY_PATTERNS = ["priority", "urgency", "level", "importance"];
 
 function pickField(sample: DynamicRecord, patterns: string[]): string | null {
   for (const p of patterns) {
-    if (p in sample) return p
+    if (p in sample) return p;
   }
-  return null
+  return null;
 }
 
 export function resolveInboxConfig(
   data: DynamicRecord[],
   user?: InboxConfig,
-): Required<Omit<InboxConfig, "titlePath" | "previewPath">> & Pick<InboxConfig, "titlePath" | "previewPath"> {
-  const sample = data?.[0] && typeof data[0] === "object" ? data[0] : {}
+): Required<Omit<InboxConfig, "titlePath" | "previewPath">> &
+  Pick<InboxConfig, "titlePath" | "previewPath"> {
+  const sample = data?.[0] && typeof data[0] === "object" ? data[0] : {};
 
   const auto = {
     starredField: pickField(sample, STARRED_PATTERNS),
     readField: pickField(sample, READ_PATTERNS),
     attachmentField: pickField(sample, ATTACHMENT_PATTERNS),
     priorityField: pickField(sample, PRIORITY_PATTERNS),
-  }
+  };
 
   return {
     starredField: user?.starredField !== undefined ? user.starredField : auto.starredField,
     readField: user?.readField !== undefined ? user.readField : auto.readField,
-    attachmentField: user?.attachmentField !== undefined ? user.attachmentField : auto.attachmentField,
+    attachmentField:
+      user?.attachmentField !== undefined ? user.attachmentField : auto.attachmentField,
     priorityField: user?.priorityField !== undefined ? user.priorityField : auto.priorityField,
     titlePath: user?.titlePath,
     previewPath: user?.previewPath,
-  }
+  };
 }
 
-export function readInboxField(
-  item: DynamicRecord,
-  field: string | null | undefined,
-): any {
-  if (!field) return undefined
-  return getByPath(item, field)
+export function readInboxField(item: DynamicRecord, field: string | null | undefined): unknown {
+  if (!field) return undefined;
+  return getByPath(item, field);
 }