torch-glare 2.4.4 → 2.5.0

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

@@ -1,234 +0,0 @@
-import type {
-  DynamicRecord,
-  FieldConfig,
-  FieldPreset,
-  FilterValue,
-  NumericRangeFilter,
-  DateRangeFilter,
-  RangeFilter,
-} from "../../components/DataViews/types";
-import { getByPath } from "./pathUtils";
-
-export function isRangeFilter(v: unknown): v is RangeFilter {
-  return (
-    !!v &&
-    typeof v === "object" &&
-    !Array.isArray(v) &&
-    ((v as RangeFilter).kind === "number" || (v as RangeFilter).kind === "date")
-  );
-}
-
-export function isNumericRange(v: FilterValue | undefined | null): v is NumericRangeFilter {
-  return !!v && !Array.isArray(v) && (v as RangeFilter).kind === "number";
-}
-
-export function isDateRange(v: FilterValue | undefined | null): v is DateRangeFilter {
-  return !!v && !Array.isArray(v) && (v as RangeFilter).kind === "date";
-}
-
-export function isFilterActive(v: FilterValue | undefined): boolean {
-  if (v == null) return false;
-  if (Array.isArray(v)) return v.length > 0;
-  if (isNumericRange(v)) return v.min != null || v.max != null;
-  if (isDateRange(v)) return v.from != null || v.to != null;
-  return false;
-}
-
-export function countActiveFilters(state: Record<string, FilterValue>): number {
-  let n = 0;
-  for (const v of Object.values(state)) {
-    if (isFilterActive(v)) n++;
-  }
-  return n;
-}
-
-export function describeFilterValue(v: FilterValue): string {
-  if (Array.isArray(v)) return v.join(", ");
-  if (isNumericRange(v)) {
-    if (v.min != null && v.max != null) return `${v.min} – ${v.max}`;
-    if (v.min != null) return `≥ ${v.min}`;
-    if (v.max != null) return `≤ ${v.max}`;
-    return "any";
-  }
-  if (isDateRange(v)) {
-    if (v.from && v.to) return `${v.from} → ${v.to}`;
-    if (v.from) return `from ${v.from}`;
-    if (v.to) return `until ${v.to}`;
-    return "any";
-  }
-  return "";
-}
-
-export type NumericExtremes = { min: number; max: number };
-
-export function computeNumericExtremes(
-  data: DynamicRecord[],
-  path: string,
-): NumericExtremes | null {
-  let min = Number.POSITIVE_INFINITY;
-  let max = Number.NEGATIVE_INFINITY;
-  let found = false;
-  for (const item of data) {
-    const v = getByPath(item, path);
-    const n = typeof v === "number" ? v : Number(v);
-    if (!Number.isFinite(n)) continue;
-    if (n < min) min = n;
-    if (n > max) max = n;
-    found = true;
-  }
-  return found ? { min, max } : null;
-}
-
-export function inferStep(field: FieldConfig, extremes: NumericExtremes): number {
-  if (field.rangeStep != null) return field.rangeStep;
-  switch (field.type) {
-    case "star-rating":
-      return 0.1;
-    case "progress-bar":
-      return 1;
-    case "currency": {
-      const span = extremes.max - extremes.min;
-      if (span >= 10000) return 100;
-      if (span >= 1000) return 10;
-      return 1;
-    }
-    default: {
-      const span = extremes.max - extremes.min;
-      if (span >= 10000) return 10;
-      if (span >= 100) return 1;
-      return 0.1;
-    }
-  }
-}
-
-export type DateExtremes = { from: string; to: string };
-
-export function computeDateExtremes(data: DynamicRecord[], path: string): DateExtremes | null {
-  let minMs = Number.POSITIVE_INFINITY;
-  let maxMs = Number.NEGATIVE_INFINITY;
-  let found = false;
-  for (const item of data) {
-    const v = getByPath(item, path);
-    if (v == null) continue;
-    const ms = v instanceof Date ? v.getTime() : Date.parse(String(v));
-    if (!Number.isFinite(ms)) continue;
-    if (ms < minMs) minMs = ms;
-    if (ms > maxMs) maxMs = ms;
-    found = true;
-  }
-  if (!found) return null;
-  return { from: toIsoDate(new Date(minMs)), to: toIsoDate(new Date(maxMs)) };
-}
-
-const RELATIVE = /^(-?\d+)([dwmy])$/;
-
-export function resolveRelativeDate(token: string | undefined): string | undefined {
-  if (!token) return undefined;
-  if (token === "today" || token === "now") return toIsoDate(new Date());
-  if (token === "start-of-year") {
-    const now = new Date();
-    return toIsoDate(new Date(now.getFullYear(), 0, 1));
-  }
-  const m = RELATIVE.exec(token);
-  if (m) {
-    const n = parseInt(m[1], 10);
-    const unit = m[2];
-    const d = new Date();
-    switch (unit) {
-      case "d":
-        d.setDate(d.getDate() + n);
-        break;
-      case "w":
-        d.setDate(d.getDate() + n * 7);
-        break;
-      case "m":
-        d.setMonth(d.getMonth() + n);
-        break;
-      case "y":
-        d.setFullYear(d.getFullYear() + n);
-        break;
-    }
-    return toIsoDate(d);
-  }
-  const ms = Date.parse(token);
-  if (Number.isFinite(ms)) return toIsoDate(new Date(ms));
-  return token;
-}
-
-export function toIsoDate(d: Date): string {
-  const yyyy = d.getFullYear();
-  const mm = String(d.getMonth() + 1).padStart(2, "0");
-  const dd = String(d.getDate()).padStart(2, "0");
-  return `${yyyy}-${mm}-${dd}`;
-}
-
-export function presetToFilterValue(preset: FieldPreset): RangeFilter {
-  if ("from" in preset || "to" in preset) {
-    return {
-      kind: "date",
-      from: resolveRelativeDate(preset.from),
-      to: resolveRelativeDate(preset.to),
-    };
-  }
-  return {
-    kind: "number",
-    min: (preset as { min?: number }).min,
-    max: (preset as { max?: number }).max,
-  };
-}
-
-export function isPresetActive(preset: FieldPreset, current: FilterValue | undefined): boolean {
-  if (!current) return false;
-  if (Array.isArray(current)) return false;
-  if (current.kind === "number" && !("from" in preset) && !("to" in preset)) {
-    return (
-      ((preset as { min?: number }).min ?? null) === (current.min ?? null) &&
-      ((preset as { max?: number }).max ?? null) === (current.max ?? null)
-    );
-  }
-  if (current.kind === "date" && ("from" in preset || "to" in preset)) {
-    const want = presetToFilterValue(preset) as DateRangeFilter;
-    return (
-      (want.from ?? null) === (current.from ?? null) && (want.to ?? null) === (current.to ?? null)
-    );
-  }
-  return false;
-}
-
-const DEFAULT_PRESETS: Record<string, FieldPreset[]> = {
-  currency: [
-    { label: "<$100", max: 100 },
-    { label: "$100–$500", min: 100, max: 500 },
-    { label: "$500–$2k", min: 500, max: 2000 },
-    { label: "$2k+", min: 2000 },
-  ],
-  "progress-bar": [
-    { label: "0%", min: 0, max: 0 },
-    { label: "1–40%", min: 1, max: 40 },
-    { label: "40–70%", min: 40, max: 70 },
-    { label: "70–99%", min: 70, max: 99 },
-    { label: "100%", min: 100, max: 100 },
-  ],
-  "star-rating": [
-    { label: "≥4★", min: 4 },
-    { label: "≥3★", min: 3 },
-    { label: "<3★", max: 3 },
-  ],
-  date: [
-    { label: "Today", from: "today" },
-    { label: "Last 7 days", from: "-7d" },
-    { label: "Last 30 days", from: "-30d" },
-    { label: "This year", from: "start-of-year" },
-  ],
-  "date-format": [
-    { label: "Today", from: "today" },
-    { label: "Last 7 days", from: "-7d" },
-    { label: "Last 30 days", from: "-30d" },
-    { label: "This year", from: "start-of-year" },
-  ],
-};
-
-export function resolvePresets(field: FieldConfig): FieldPreset[] {
-  if (field.presets) return field.presets;
-  return DEFAULT_PRESETS[field.type ?? ""] ?? [];
-}

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

@@ -1,396 +0,0 @@
-import type { DynamicRecord, TreeConfig } from "../../components/DataViews/types";
-import { getByPath, setByPath } from "./pathUtils";
-
-export type TreeNode = {
-  id: string;
-  record: DynamicRecord;
-  children: TreeNode[];
-  depth: number;
-  parent: TreeNode | null;
-};
-
-export type ResolvedTreeConfig = {
-  childrenField?: string;
-  parentField?: string;
-  idField: string;
-  orderField?: string;
-  nodeLabel?: string;
-  defaultExpanded: "all" | "roots" | "none";
-};
-
-const CHILDREN_PATTERNS = ["children", "items", "kids", "subItems", "nodes"];
-const PARENT_PATTERNS = ["parentId", "parent_id", "parent", "managerId", "manager"];
-const ID_PATTERNS = ["id", "_id", "uuid", "key"];
-
-export function autoDetectTreeShape(data: DynamicRecord[], config: TreeConfig): ResolvedTreeConfig {
-  const sample = data.find((r) => r != null && typeof r === "object") ?? {};
-
-  const idField = config.idField ?? pickKey(sample, ID_PATTERNS) ?? "id";
-
-  let childrenField = config.childrenField;
-  let parentField = config.parentField;
-
-  if (!childrenField && !parentField) {
-    childrenField = pickArrayKey(sample, CHILDREN_PATTERNS);
-    if (!childrenField) parentField = pickKey(sample, PARENT_PATTERNS);
-  }
-
-  return {
-    childrenField,
-    parentField,
-    idField,
-    orderField: config.orderField,
-    nodeLabel: config.nodeLabel,
-    defaultExpanded: config.defaultExpanded ?? "roots",
-  };
-}
-
-function pickKey(record: DynamicRecord, candidates: string[]): string | undefined {
-  for (const key of candidates) {
-    if (key in record) return key;
-  }
-  return undefined;
-}
-
-function pickArrayKey(record: DynamicRecord, candidates: string[]): string | undefined {
-  for (const key of candidates) {
-    if (key in record && Array.isArray(record[key])) return key;
-  }
-  return undefined;
-}
-
-export function buildTree(data: DynamicRecord[], config: ResolvedTreeConfig): TreeNode[] {
-  if (!data || data.length === 0) return [];
-  if (config.childrenField) return buildFromNested(data, config);
-  if (config.parentField) return buildFromFlat(data, config);
-  return data.map((record, idx) => makeNode(record, config, idx, null, 0));
-}
-
-function buildFromNested(data: DynamicRecord[], config: ResolvedTreeConfig): TreeNode[] {
-  const seen = new Set<string>();
-
-  const visit = (
-    record: DynamicRecord,
-    depth: number,
-    parent: TreeNode | null,
-    idx: number,
-  ): TreeNode => {
-    const node = makeNode(record, config, idx, parent, depth);
-    if (seen.has(node.id)) {
-      return { ...node, children: [] };
-    }
-    seen.add(node.id);
-
-    const rawChildren = getByPath(record, config.childrenField);
-    if (Array.isArray(rawChildren)) {
-      node.children = rawChildren.map((child, ci) => visit(child, depth + 1, node, ci));
-    }
-    return node;
-  };
-
-  return data.map((record, idx) => visit(record, 0, null, idx));
-}
-
-function buildFromFlat(data: DynamicRecord[], config: ResolvedTreeConfig): TreeNode[] {
-  const byId = new Map<string, TreeNode>();
-  for (let i = 0; i < data.length; i++) {
-    const record = data[i];
-    const id = String(getByPath(record, config.idField) ?? `__row${i}`);
-    byId.set(id, {
-      id,
-      record,
-      children: [],
-      depth: 0,
-      parent: null,
-    });
-  }
-
-  const roots: TreeNode[] = [];
-  for (const node of byId.values()) {
-    const parentId = getByPath(node.record, config.parentField);
-    if (parentId == null) {
-      roots.push(node);
-      continue;
-    }
-    const parent = byId.get(String(parentId));
-    if (!parent || parent === node) {
-      roots.push(node);
-      continue;
-    }
-    node.parent = parent;
-    parent.children.push(node);
-  }
-
-  const setDepth = (n: TreeNode, d: number, guard = new Set<TreeNode>()) => {
-    if (guard.has(n)) return;
-    guard.add(n);
-    n.depth = d;
-    for (const c of n.children) setDepth(c, d + 1, guard);
-  };
-  for (const r of roots) setDepth(r, 0);
-
-  return roots;
-}
-
-function makeNode(
-  record: DynamicRecord,
-  config: ResolvedTreeConfig,
-  idx: number,
-  parent: TreeNode | null,
-  depth: number,
-): TreeNode {
-  const idValue = getByPath(record, config.idField);
-  const id = idValue != null ? String(idValue) : `__row${idx}`;
-  return { id, record, children: [], depth, parent };
-}
-
-export function findNodeById(roots: TreeNode[], id: string): TreeNode | null {
-  for (const root of roots) {
-    if (root.id === id) return root;
-    const inChild = findNodeById(root.children, id);
-    if (inChild) return inChild;
-  }
-  return null;
-}
-
-export function* walk(node: TreeNode): Generator<TreeNode> {
-  yield node;
-  for (const c of node.children) yield* walk(c);
-}
-
-export function flatten(node: TreeNode): DynamicRecord[] {
-  const out: DynamicRecord[] = [];
-  for (const n of walk(node)) out.push(n.record);
-  return out;
-}
-
-export function descendantIds(node: TreeNode): Set<string> {
-  const out = new Set<string>();
-  for (const n of walk(node)) out.add(n.id);
-  return out;
-}
-
-export function allIds(roots: TreeNode[]): Set<string> {
-  const out = new Set<string>();
-  for (const r of roots) for (const n of walk(r)) out.add(n.id);
-  return out;
-}
-
-export function initialExpansion(roots: TreeNode[], mode: "all" | "roots" | "none"): Set<string> {
-  if (mode === "none") return new Set();
-  if (mode === "roots") return new Set(roots.map((r) => r.id));
-  return allIds(roots);
-}
-
-export function flattenAll(data: DynamicRecord[], childrenField: string): DynamicRecord[] {
-  const out: DynamicRecord[] = [];
-  const dfs = (record: DynamicRecord) => {
-    if (record == null || typeof record !== "object") return;
-    const { [childrenField]: kids, ...rest } = record;
-    out.push(rest as DynamicRecord);
-    if (Array.isArray(kids)) for (const k of kids) dfs(k);
-  };
-  for (const r of data) dfs(r);
-  return out;
-}
-
-export type MoveArgs = {
-  dragIds: string[];
-  parentId: string | null;
-  index: number;
-};
-
-export function applyMove(
-  data: DynamicRecord[],
-  config: ResolvedTreeConfig,
-  args: MoveArgs,
-): DynamicRecord[] {
-  if (config.childrenField) return applyMoveNested(data, config, args);
-  if (config.parentField) return applyMoveFlat(data, config, args);
-  return applyMoveTopLevel(data, config, args);
-}
-
-function recordId(record: DynamicRecord, idField: string, fallbackIdx: number): string {
-  const v = getByPath(record, idField);
-  return v != null ? String(v) : `__row${fallbackIdx}`;
-}
-
-function applyMoveTopLevel(
-  data: DynamicRecord[],
-  config: ResolvedTreeConfig,
-  args: MoveArgs,
-): DynamicRecord[] {
-  const ids = new Set(args.dragIds);
-  const dragged: DynamicRecord[] = [];
-  const remaining: DynamicRecord[] = [];
-  data.forEach((rec, i) => {
-    if (ids.has(recordId(rec, config.idField, i))) dragged.push(rec);
-    else remaining.push(rec);
-  });
-  const target = args.parentId == null ? remaining : remaining;
-  const insertAt = Math.max(0, Math.min(args.index, target.length));
-  return [...target.slice(0, insertAt), ...dragged, ...target.slice(insertAt)];
-}
-
-function applyMoveFlat(
-  data: DynamicRecord[],
-  config: ResolvedTreeConfig,
-  args: MoveArgs,
-): DynamicRecord[] {
-  const idField = config.idField;
-  const parentField = config.parentField!;
-  const orderField = config.orderField;
-
-  const dragSet = new Set(args.dragIds);
-
-  if (args.parentId) {
-    for (const d of data) {
-      const id = String(getByPath(d, idField) ?? "");
-      if (!dragSet.has(id)) continue;
-      let cur: string | null = args.parentId;
-      while (cur) {
-        if (cur === id) return data;
-        const search = cur;
-        const parentRec = data.find((r) => String(getByPath(r, idField) ?? "") === search);
-        if (!parentRec) break;
-        const next = getByPath(parentRec, parentField);
-        cur = next == null ? null : String(next);
-      }
-    }
-  }
-
-  const updatedParent: DynamicRecord[] = data.map((rec) => {
-    const id = String(getByPath(rec, idField) ?? "");
-    if (!dragSet.has(id)) return rec;
-    return setByPath(rec, parentField, args.parentId ?? null);
-  });
-
-  if (!orderField) return updatedParent;
-
-  const siblingsAfter = updatedParent.filter((rec) => {
-    const p = getByPath(rec, parentField);
-    const norm = p == null ? null : String(p);
-    return norm === (args.parentId ?? null);
-  });
-
-  const dragged: DynamicRecord[] = [];
-  const others: DynamicRecord[] = [];
-  siblingsAfter.forEach((rec) => {
-    const id = String(getByPath(rec, idField) ?? "");
-    if (dragSet.has(id)) dragged.push(rec);
-    else others.push(rec);
-  });
-
-  const insertAt = Math.max(0, Math.min(args.index, others.length));
-  const newOrder = [...others.slice(0, insertAt), ...dragged, ...others.slice(insertAt)];
-  const orderById = new Map<string, number>();
-  newOrder.forEach((rec, i) => {
-    const id = String(getByPath(rec, idField) ?? "");
-    orderById.set(id, i);
-  });
-
-  return updatedParent.map((rec) => {
-    const id = String(getByPath(rec, idField) ?? "");
-    if (!orderById.has(id)) return rec;
-    return setByPath(rec, orderField, orderById.get(id)!);
-  });
-}
-
-function applyMoveNested(
-  data: DynamicRecord[],
-  config: ResolvedTreeConfig,
-  args: MoveArgs,
-): DynamicRecord[] {
-  const childrenField = config.childrenField!;
-  const idField = config.idField;
-  const dragSet = new Set(args.dragIds);
-
-  const isAncestorOfDrag = (record: DynamicRecord, ancestors: DynamicRecord[]): boolean => {
-    const id = String(getByPath(record, idField) ?? "");
-    if (dragSet.has(id)) {
-      for (const a of ancestors) {
-        const aid = String(getByPath(a, idField) ?? "");
-        if (aid === args.parentId) return true;
-      }
-    }
-    const kids = getByPath(record, childrenField);
-    if (Array.isArray(kids)) {
-      for (const k of kids) {
-        if (isAncestorOfDrag(k, [...ancestors, record])) return true;
-      }
-    }
-    return false;
-  };
-  for (const r of data) if (isAncestorOfDrag(r, [])) return data;
-
-  const extracted: DynamicRecord[] = [];
-  const extract = (records: DynamicRecord[]): DynamicRecord[] =>
-    records
-      .map((rec) => {
-        const id = String(getByPath(rec, idField) ?? "");
-        const kids = getByPath(rec, childrenField);
-        const newKids = Array.isArray(kids) ? extract(kids) : kids;
-        const next = Array.isArray(kids) ? setByPath(rec, childrenField, newKids) : rec;
-        if (dragSet.has(id)) {
-          extracted.push(next);
-          return null;
-        }
-        return next;
-      })
-      .filter((r): r is DynamicRecord => r !== null);
-
-  const pruned = extract(data);
-
-  const insert = (records: DynamicRecord[]): DynamicRecord[] =>
-    records.map((rec) => {
-      const id = String(getByPath(rec, idField) ?? "");
-      if (id === args.parentId) {
-        const kids = getByPath(rec, childrenField);
-        const arr = Array.isArray(kids) ? [...kids] : [];
-        const at = Math.max(0, Math.min(args.index, arr.length));
-        arr.splice(at, 0, ...extracted);
-        return setByPath(rec, childrenField, arr);
-      }
-      const kids = getByPath(rec, childrenField);
-      if (Array.isArray(kids)) {
-        return setByPath(rec, childrenField, insert(kids));
-      }
-      return rec;
-    });
-
-  if (args.parentId == null) {
-    const at = Math.max(0, Math.min(args.index, pruned.length));
-    return [...pruned.slice(0, at), ...extracted, ...pruned.slice(at)];
-  }
-
-  return insert(pruned);
-}
-
-export function pruneTree(
-  roots: TreeNode[],
-  predicate: (record: DynamicRecord) => boolean,
-): TreeNode[] {
-  const visit = (node: TreeNode, parent: TreeNode | null): TreeNode | null => {
-    const newChildren: TreeNode[] = [];
-    for (const c of node.children) {
-      const next = visit(c, node);
-      if (next) newChildren.push(next);
-    }
-    const selfMatches = predicate(node.record);
-    if (!selfMatches && newChildren.length === 0) return null;
-    return {
-      id: node.id,
-      record: node.record,
-      depth: node.depth,
-      parent,
-      children: newChildren,
-    };
-  };
-
-  const out: TreeNode[] = [];
-  for (const r of roots) {
-    const next = visit(r, null);
-    if (next) out.push(next);
-  }
-  return out;
-}