torch-glare 2.4.0 → 2.4.2

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/color.ts

@@ -0,0 +1,175 @@
+/**
+ * Pure color-math helpers for the `ColorPicker` component (and anything else that
+ * needs to move between hex, RGB, HSV and HSL). No dependencies, no DOM — safe to
+ * unit-test and to import on the server.
+ *
+ * Conventions:
+ *  - `RGBA` channels are 0–255 (`r`,`g`,`b`) and 0–1 (`a`).
+ *  - `HSV`/`HSL` use `h` 0–360, everything else 0–100.
+ *  - Hex output is uppercase, `#rrggbb` when fully opaque and `#rrggbbaa` otherwise.
+ */
+
+export interface RGBA {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+
+export interface HSV {
+  h: number;
+  s: number;
+  v: number;
+}
+
+export interface HSL {
+  h: number;
+  s: number;
+  l: number;
+}
+
+/** Clamp `n` into the inclusive `[min, max]` range. */
+export function clamp(n: number, min: number, max: number): number {
+  return n < min ? min : n > max ? max : n;
+}
+
+/** Round to `digits` decimal places (default 0). */
+export function round(n: number, digits = 0): number {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+}
+
+const toHex2 = (n: number) => clamp(Math.round(n), 0, 255).toString(16).padStart(2, "0");
+
+/**
+ * Parse a hex color into `RGBA`. Accepts `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`
+ * with or without the leading `#`. Returns `null` for anything unparseable.
+ */
+export function parseHex(input: string): RGBA | null {
+  if (typeof input !== "string") return null;
+  let hex = input.trim().replace(/^#/, "");
+
+  // Expand shorthand (#rgb / #rgba → #rrggbb(aa)).
+  if (hex.length === 3 || hex.length === 4) {
+    hex = hex
+      .split("")
+      .map((c) => c + c)
+      .join("");
+  }
+
+  if (hex.length !== 6 && hex.length !== 8) return null;
+  if (!/^[0-9a-fA-F]+$/.test(hex)) return null;
+
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  const a = hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1;
+  return { r, g, b, a: round(a, 2) };
+}
+
+/** Format `RGBA` as an uppercase hex string — `#rrggbb` if opaque, else `#rrggbbaa`. */
+export function formatHex({ r, g, b, a }: RGBA): string {
+  const base = `#${toHex2(r)}${toHex2(g)}${toHex2(b)}`.toUpperCase();
+  if (a >= 1) return base;
+  return `${base}${toHex2(clamp(a, 0, 1) * 255).toUpperCase()}`;
+}
+
+/** RGB (0–255) → HSV (h 0–360, s/v 0–100). Alpha is carried through unchanged elsewhere. */
+export function rgbToHsv({ r, g, b }: { r: number; g: number; b: number }): HSV {
+  const rn = r / 255;
+  const gn = g / 255;
+  const bn = b / 255;
+  const max = Math.max(rn, gn, bn);
+  const min = Math.min(rn, gn, bn);
+  const d = max - min;
+
+  let h = 0;
+  if (d !== 0) {
+    if (max === rn) h = ((gn - bn) / d) % 6;
+    else if (max === gn) h = (bn - rn) / d + 2;
+    else h = (rn - gn) / d + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  const s = max === 0 ? 0 : d / max;
+  // Keep 2 decimals: HSV is the picker's internal state, so rounding to whole degrees/percents
+  // here would visibly shift a color that was only ever passed in (e.g. #10B981 → #11BA82).
+  return { h: round(h, 2), s: round(s * 100, 2), v: round(max * 100, 2) };
+}
+
+/** HSV (h 0–360, s/v 0–100) → RGB (0–255). */
+export function hsvToRgb({ h, s, v }: HSV): { r: number; g: number; b: number } {
+  const hn = ((h % 360) + 360) % 360;
+  const sn = clamp(s, 0, 100) / 100;
+  const vn = clamp(v, 0, 100) / 100;
+
+  const c = vn * sn;
+  const x = c * (1 - Math.abs(((hn / 60) % 2) - 1));
+  const m = vn - c;
+
+  let rp = 0;
+  let gp = 0;
+  let bp = 0;
+  if (hn < 60) [rp, gp, bp] = [c, x, 0];
+  else if (hn < 120) [rp, gp, bp] = [x, c, 0];
+  else if (hn < 180) [rp, gp, bp] = [0, c, x];
+  else if (hn < 240) [rp, gp, bp] = [0, x, c];
+  else if (hn < 300) [rp, gp, bp] = [x, 0, c];
+  else [rp, gp, bp] = [c, 0, x];
+
+  return {
+    r: round((rp + m) * 255),
+    g: round((gp + m) * 255),
+    b: round((bp + m) * 255),
+  };
+}
+
+/** RGB (0–255) → HSL (h 0–360, s/l 0–100). */
+export function rgbToHsl({ r, g, b }: { r: number; g: number; b: number }): HSL {
+  const rn = r / 255;
+  const gn = g / 255;
+  const bn = b / 255;
+  const max = Math.max(rn, gn, bn);
+  const min = Math.min(rn, gn, bn);
+  const d = max - min;
+  const l = (max + min) / 2;
+
+  let h = 0;
+  let s = 0;
+  if (d !== 0) {
+    s = d / (1 - Math.abs(2 * l - 1));
+    if (max === rn) h = ((gn - bn) / d) % 6;
+    else if (max === gn) h = (bn - rn) / d + 2;
+    else h = (rn - gn) / d + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  return { h: round(h), s: round(s * 100), l: round(l * 100) };
+}
+
+/** HSL (h 0–360, s/l 0–100) → RGB (0–255). */
+export function hslToRgb({ h, s, l }: HSL): { r: number; g: number; b: number } {
+  const hn = ((h % 360) + 360) % 360;
+  const sn = clamp(s, 0, 100) / 100;
+  const ln = clamp(l, 0, 100) / 100;
+
+  const c = (1 - Math.abs(2 * ln - 1)) * sn;
+  const x = c * (1 - Math.abs(((hn / 60) % 2) - 1));
+  const m = ln - c / 2;
+
+  let rp = 0;
+  let gp = 0;
+  let bp = 0;
+  if (hn < 60) [rp, gp, bp] = [c, x, 0];
+  else if (hn < 120) [rp, gp, bp] = [x, c, 0];
+  else if (hn < 180) [rp, gp, bp] = [0, c, x];
+  else if (hn < 240) [rp, gp, bp] = [0, x, c];
+  else if (hn < 300) [rp, gp, bp] = [x, 0, c];
+  else [rp, gp, bp] = [c, 0, x];
+
+  return {
+    r: round((rp + m) * 255),
+    g: round((gp + m) * 255),
+    b: round((bp + m) * 255),
+  };
+}

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);
 }