Fix some ts-strict-ignore (#6440)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: lkostrowski

scripts/strict-ignore-importers.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Finds all files with `@ts-strict-ignore` and traces their full importer tree.
+ *
+ * Uses dependency-cruiser to build a reverse import graph, then for each
+ * strict-ignored file walks up the importer chain — following through
+ * barrel files (index.ts) and re-exports so you see the real consumers.
+ *
+ * Usage: node scripts/strict-ignore-importers.mjs
+ */
+
+import { execSync } from "node:child_process";
+import { basename } from "node:path";
+
+const ROOT = new URL("..", import.meta.url).pathname.replace(/\/$/, "");
+
+// ── 1. Gather files with @ts-strict-ignore ──────────────────────────────────
+
+function findStrictIgnoreFiles() {
+  // Safe: no user input, hardcoded command
+  const out = execSync(`grep -rl "@ts-strict-ignore" src/ --include="*.ts" --include="*.tsx"`, {
+    cwd: ROOT,
+    encoding: "utf8",
+  });
+  return new Set(out.trim().split("\n").filter(Boolean));
+}
+
+// ── 2. Build reverse import graph via dependency-cruiser ────────────────────
+
+function buildReverseGraph() {
+  console.error("⏳ Running dependency-cruiser (this takes a moment)…");
+
+  // Safe: no user input, hardcoded command
+  const json = execSync(`npx depcruise --output-type json --no-config src/`, {
+    cwd: ROOT,
+    encoding: "utf8",
+    maxBuffer: 200 * 1024 * 1024,
+  });
+
+  const { modules } = JSON.parse(json);
+
+  // reverseGraph: resolved target → Set of sources that import it
+  const reverseGraph = new Map();
+
+  for (const mod of modules) {
+    if (!mod.dependencies) continue;
+    for (const dep of mod.dependencies) {
+      if (!dep.resolved || dep.couldNotResolve) continue;
+      if (!reverseGraph.has(dep.resolved)) {
+        reverseGraph.set(dep.resolved, new Set());
+      }
+      reverseGraph.get(dep.resolved).add(mod.source);
+    }
+  }
+
+  console.error(`✅ Graph built: ${modules.length} modules, ${reverseGraph.size} imported files`);
+  return reverseGraph;
+}
+
+// ── 3. Walk the importer tree ───────────────────────────────────────────────
+
+function isBarrelFile(filePath) {
+  const name = basename(filePath);
+  return /^index\.(ts|tsx|js|jsx)$/.test(name);
+}
+
+/**
+ * Recursively collect the full importer tree for `file`.
+ * Barrel files (index.ts) are followed through — their importers are
+ * included instead of (or in addition to) the barrel itself.
+ *
+ * Returns a Map: importer path → depth (shortest path distance).
+ */
+function traceImporters(file, reverseGraph) {
+  const result = new Map();
+  const visited = new Set();
+
+  function walk(current, depth) {
+    if (visited.has(current)) return;
+    visited.add(current);
+
+    const importers = reverseGraph.get(current);
+    if (!importers) return;
+
+    for (const imp of importers) {
+      if (isBarrelFile(current)) {
+        if (!result.has(current)) result.set(current, depth);
+        walk(imp, depth);
+      } else if (isBarrelFile(imp)) {
+        if (!result.has(imp)) result.set(imp, depth);
+        walk(imp, depth + 1);
+      } else {
+        if (!result.has(imp)) result.set(imp, depth);
+      }
+    }
+  }
+
+  walk(file, 1);
+  return result;
+}
+
+// ── 4. Main ─────────────────────────────────────────────────────────────────
+
+const strictIgnoreFiles = findStrictIgnoreFiles();
+console.error(`📁 Found ${strictIgnoreFiles.size} files with @ts-strict-ignore`);
+
+const reverseGraph = buildReverseGraph();
+
+const results = [];
+
+for (const file of [...strictIgnoreFiles].sort()) {
+  const importers = traceImporters(file, reverseGraph);
+
+  const barrels = [];
+  const consumers = [];
+  for (const [imp, depth] of importers) {
+    if (isBarrelFile(imp)) {
+      barrels.push({ path: imp, depth });
+    } else {
+      consumers.push({ path: imp, depth });
+    }
+  }
+
+  const consumerDetails = consumers.map(c => ({
+    ...c,
+    alsoStrictIgnored: strictIgnoreFiles.has(c.path),
+  }));
+
+  const allConsumersStrict =
+    consumers.length === 0 || consumerDetails.every(c => !c.alsoStrictIgnored);
+
+  results.push({
+    file,
+    directImporterCount: reverseGraph.get(file)?.size ?? 0,
+    totalConsumers: consumers.length,
+    barrels,
+    consumers: consumerDetails,
+    ready: allConsumersStrict,
+  });
+}
+
+// ── 5. Print output ─────────────────────────────────────────────────────────
+
+const readyFiles = results.filter(r => r.ready);
+const byConsumerCount = [
+  { label: "0 consumers (leaf)", items: results.filter(r => r.totalConsumers === 0) },
+  { label: "1 consumer", items: results.filter(r => r.totalConsumers === 1) },
+  {
+    label: "2-4 consumers",
+    items: results.filter(r => r.totalConsumers >= 2 && r.totalConsumers <= 4),
+  },
+  { label: "5+ consumers", items: results.filter(r => r.totalConsumers >= 5) },
+];
+
+console.log("=".repeat(80));
+console.log("  @ts-strict-ignore IMPORTER ANALYSIS");
+console.log("=".repeat(80));
+console.log();
+console.log(`Total files with @ts-strict-ignore: ${results.length}`);
+console.log(`Ready to fix (all consumers are already strict): ${readyFiles.length}`);
+console.log();
+
+console.log("Distribution by consumer count:");
+for (const bucket of byConsumerCount) {
+  console.log(`  ${bucket.label}: ${bucket.items.length}`);
+}
+console.log();
+
+console.log("─".repeat(80));
+console.log("READY TO FIX (no strict-ignored consumers):");
+console.log("─".repeat(80));
+for (const r of readyFiles) {
+  const tag =
+    r.totalConsumers === 0
+      ? "[leaf]"
+      : `[${r.totalConsumers} consumer${r.totalConsumers > 1 ? "s" : ""}]`;
+  console.log(`  ${tag} ${r.file}`);
+  for (const b of r.barrels) {
+    console.log(`         ↳ via barrel: ${b.path}`);
+  }
+  for (const c of r.consumers) {
+    console.log(`         → ${c.path}`);
+  }
+}
+
+console.log();
+console.log("─".repeat(80));
+console.log("ALL FILES (detailed importer tree):");
+console.log("─".repeat(80));
+
+for (const r of results) {
+  const readyMark = r.ready ? "✅" : "  ";
+  console.log(
+    `\n${readyMark} ${r.file}  (direct: ${r.directImporterCount}, total consumers: ${r.totalConsumers})`,
+  );
+
+  if (r.barrels.length > 0) {
+    for (const b of r.barrels) {
+      console.log(`     ↳ barrel: ${b.path}`);
+    }
+  }
+
+  if (r.consumers.length > 0) {
+    for (const c of r.consumers) {
+      const strictTag = c.alsoStrictIgnored ? " ⚠️  @ts-strict-ignore" : "";
+      console.log(`     → ${c.path}${strictTag}`);
+    }
+  } else {
+    console.log("     (no consumers found — leaf file)");
+  }
+}
+
+console.log();
+console.log("─".repeat(80));
+console.log("TOP 20 BY CONSUMER COUNT:");
+console.log("─".repeat(80));
+const sorted = [...results].sort((a, b) => b.totalConsumers - a.totalConsumers);
+for (const r of sorted.slice(0, 20)) {
+  const readyMark = r.ready ? "✅" : "❌";
+  console.log(`  ${readyMark} ${r.totalConsumers.toString().padStart(4)} consumers  ${r.file}`);
+}

src/components/Date/DateTime.tsx

@@ -1,4 +1,3 @@
-// @ts-strict-ignore
 import { useCurrentDate } from "@dashboard/hooks/useCurrentDate";
 import { Tooltip } from "@saleor/macaw-ui-next";
 import moment from "moment-timezone";
@@ -16,7 +15,7 @@ export const DateTime = ({ date, plain }: DateTimeProps) => {
   const currentDate = useCurrentDate();
 
   const getTitle = (value: string, locale?: string, tz?: string) => {
-    let date = moment(value).locale(locale);
+    let date: moment.Moment = locale ? moment(value).locale(locale) : moment(value);
 
     if (tz !== undefined) {
       date = date.tz(tz);

src/components/Metadata/utils.test.ts

@@ -0,0 +1,116 @@
+import { type ChangeEvent } from "@dashboard/hooks/useForm";
+
+import { EventDataAction, EventDataField } from "./types";
+import { getDataKey, getMetadataTitle, parseEventData } from "./utils";
+
+describe("parseEventData", () => {
+  it("parses name field update event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "name:2", value: "my-key" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.update,
+      field: EventDataField.name,
+      fieldIndex: 2,
+      value: "my-key",
+    });
+  });
+
+  it("parses value field update event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "value:5", value: "my-value" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.update,
+      field: EventDataField.value,
+      fieldIndex: 5,
+      value: "my-value",
+    });
+  });
+
+  it("parses add action event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "add", value: "" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.add,
+      field: null,
+      fieldIndex: null,
+      value: "",
+    });
+  });
+
+  it("parses delete action event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "delete", value: "3" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.delete,
+      field: null,
+      fieldIndex: 3,
+      value: "",
+    });
+  });
+
+  it("throws on invalid event action", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "unknown-action", value: "" },
+    };
+
+    // Act & Assert
+    expect(() => parseEventData(event)).toThrow('Invalid metadata event action: "unknown-action"');
+  });
+});
+
+describe("getDataKey", () => {
+  it("returns 'privateMetadata' when isPrivate is true", () => {
+    expect(getDataKey(true)).toBe("privateMetadata");
+  });
+
+  it("returns 'metadata' when isPrivate is false", () => {
+    expect(getDataKey(false)).toBe("metadata");
+  });
+});
+
+describe("getMetadataTitle", () => {
+  it("returns private metadata message descriptor when isPrivate is true", () => {
+    expect(getMetadataTitle(true)).toEqual({
+      id: "ETHnjq",
+      defaultMessage: "Private Metadata",
+      description: "header",
+    });
+  });
+
+  it("returns metadata message descriptor when isPrivate is false", () => {
+    expect(getMetadataTitle(false)).toEqual({
+      id: "VcI+Zh",
+      defaultMessage: "Metadata",
+      description: "header",
+    });
+  });
+});