@truedat/df 8.13.4 → 8.13.6

package/src/templates/utils/__tests__/dateRestrictions.spec.js

@@ -0,0 +1,578 @@
+import {
+  resolveRestrictions,
+  compareToLimits,
+  checkValuesAgainstBounds,
+} from "../dateRestrictions";
+
+const NOW = "2026-01-31T14:35:47.123Z";
+
+describe.each(["date", "datetime"])("resolveRestrictions (%s)", (type) => {
+  it.each([
+    ["undefined restrictions", undefined],
+    ["null restrictions", null],
+    ["empty restrictions", {}],
+  ])("leaves both bounds open with %s", (_name, restrictions) => {
+    expect(resolveRestrictions(restrictions, type, new Date(NOW))).toEqual({
+      min: undefined,
+      max: undefined,
+    });
+  });
+
+  describe("static bounds", () => {
+    it.each([
+      {
+        name: "minimum only",
+        restrictions: { min_date: { mode: "static", value: "2026-02-01" } },
+        min: "2026-02-01",
+      },
+      {
+        name: "maximum only",
+        restrictions: { max_date: { mode: "static", value: "2026-02-28" } },
+        max: "2026-02-28",
+      },
+      {
+        name: "independent minimum and maximum",
+        restrictions: {
+          min_date: { mode: "static", value: "2026-02-01" },
+          max_date: { mode: "static", value: "2026-02-28" },
+        },
+        min: "2026-02-01",
+        max: "2026-02-28",
+      },
+      {
+        name: "between with mode on the parent",
+        restrictions: {
+          between: { mode: "static", start: "2026-02-01", end: "2026-02-28" },
+        },
+        min: "2026-02-01",
+        max: "2026-02-28",
+      },
+      {
+        name: "between with an open end",
+        restrictions: { between: { mode: "static", start: "2026-02-01" } },
+        min: "2026-02-01",
+      },
+      {
+        name: "between with an open start",
+        restrictions: { between: { mode: "static", end: "2026-02-28" } },
+        max: "2026-02-28",
+      },
+      {
+        name: "legacy between keys",
+        restrictions: {
+          between_start: "2026-02-01",
+          between_end: "2026-02-28",
+        },
+        min: "2026-02-01",
+        max: "2026-02-28",
+      },
+      {
+        name: "legacy between with an open end",
+        restrictions: { between_start: "2026-02-01" },
+        min: "2026-02-01",
+      },
+      {
+        name: "legacy between with an open start",
+        restrictions: { between_end: "2026-02-28" },
+        max: "2026-02-28",
+      },
+      {
+        name: "explicit limits tighten a wider between range",
+        restrictions: {
+          min_date: { mode: "static", value: "2026-02-10" },
+          max_date: { mode: "static", value: "2026-02-20" },
+          between: { mode: "static", start: "2026-02-01", end: "2026-02-28" },
+        },
+        min: "2026-02-10",
+        max: "2026-02-20",
+      },
+      {
+        name: "between tightens wider explicit limits",
+        restrictions: {
+          min_date: { mode: "static", value: "2026-02-01" },
+          max_date: { mode: "static", value: "2026-02-28" },
+          between: { mode: "static", start: "2026-02-10", end: "2026-02-20" },
+        },
+        min: "2026-02-10",
+        max: "2026-02-20",
+      },
+    ])("$name", ({ restrictions, min, max }) => {
+      expect(resolveRestrictions(restrictions, type, new Date(NOW))).toEqual({
+        min: min && (type === "datetime" ? `${min}T00:00` : min),
+        max: max && (type === "datetime" ? `${max}T23:59` : max),
+      });
+    });
+
+    it.each(["2000-01-01T00:00:00Z", "2040-12-31T23:59:00Z"])(
+      "does not depend on now (%s)",
+      (now) => {
+        expect(
+          resolveRestrictions(
+            {
+              between: {
+                mode: "static",
+                start: "2026-02-01",
+                end: "2026-02-28",
+              },
+            },
+            type,
+            new Date(now),
+          ),
+        ).toEqual({
+          min: type === "date" ? "2026-02-01" : "2026-02-01T00:00",
+          max: type === "date" ? "2026-02-28" : "2026-02-28T23:59",
+        });
+      },
+    );
+  });
+
+  describe("relative bounds anchored to explicit now", () => {
+    it.each([
+      {
+        name: "positive minimum days cross a month boundary into the past",
+        now: "2026-03-01T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: 1, unit: "days" },
+        },
+        min: "2026-02-28",
+      },
+      {
+        name: "legacy negative minimum days remain in the past",
+        now: "2026-03-01T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: -1, unit: "days" },
+        },
+        min: "2026-02-28",
+      },
+      {
+        name: "positive days cross a year boundary",
+        now: "2025-12-31T14:35:47.123Z",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: 1, unit: "days" },
+        },
+        max: "2026-01-01",
+      },
+      {
+        name: "negative maximum days point into the past",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: -1, unit: "days" },
+        },
+        max: "2026-01-30",
+      },
+      {
+        name: "zero offsets keep the current day and minute",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: 0, unit: "days" },
+          max_date: { mode: "dynamic", amount: "0", unit: "months" },
+        },
+        min: "2026-01-31",
+        max: "2026-01-31",
+      },
+      {
+        name: "positive integer string minimum weeks cross a year boundary",
+        now: "2026-01-03T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: "1", unit: "weeks" },
+        },
+        min: "2025-12-27",
+      },
+      {
+        name: "legacy negative integer string weeks cross a year boundary",
+        now: "2026-01-03T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: "-1", unit: "weeks" },
+        },
+        min: "2025-12-27",
+      },
+      {
+        name: "positive integer string weeks cross a month boundary",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: "2", unit: "weeks" },
+        },
+        max: "2026-02-14",
+      },
+      {
+        name: "positive months clamp to non-leap February",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: 1, unit: "months" },
+        },
+        max: "2026-02-28",
+      },
+      {
+        name: "positive months clamp to leap February",
+        now: "2024-01-31T14:35:47.123Z",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: 1, unit: "months" },
+        },
+        max: "2024-02-29",
+      },
+      {
+        name: "positive minimum months clamp to leap February",
+        now: "2024-03-31T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: 1, unit: "months" },
+        },
+        min: "2024-02-29",
+      },
+      {
+        name: "legacy negative months clamp to leap February",
+        now: "2024-03-31T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: -1, unit: "months" },
+        },
+        min: "2024-02-29",
+      },
+      {
+        name: "positive minimum months cross a year boundary",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: 2, unit: "months" },
+        },
+        min: "2025-11-30",
+      },
+      {
+        name: "legacy negative months cross a year boundary",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: -2, unit: "months" },
+        },
+        min: "2025-11-30",
+      },
+      {
+        name: "positive months cross a year boundary",
+        now: "2025-12-31T14:35:47.123Z",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: 2, unit: "months" },
+        },
+        max: "2026-02-28",
+      },
+      {
+        name: "positive years clamp leap day",
+        now: "2024-02-29T14:35:47.123Z",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: 1, unit: "years" },
+        },
+        max: "2025-02-28",
+      },
+      {
+        name: "positive minimum years clamp leap day",
+        now: "2024-02-29T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: 1, unit: "years" },
+        },
+        min: "2023-02-28",
+      },
+      {
+        name: "legacy negative years clamp leap day",
+        now: "2024-02-29T14:35:47.123Z",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: -1, unit: "years" },
+        },
+        min: "2023-02-28",
+      },
+      {
+        name: "four years preserve leap day",
+        now: "2024-02-29T14:35:47.123Z",
+        restrictions: {
+          max_date: { mode: "dynamic", amount: 4, unit: "years" },
+        },
+        max: "2028-02-29",
+      },
+      {
+        name: "dynamic between uses parent mode and mixed units",
+        restrictions: {
+          between: {
+            mode: "dynamic",
+            from: { amount: -1, unit: "weeks" },
+            to: { amount: 1, unit: "months" },
+          },
+        },
+        min: "2026-01-24",
+        max: "2026-02-28",
+      },
+      {
+        name: "dynamic between preserves signed offsets",
+        restrictions: {
+          between: {
+            mode: "dynamic",
+            from: { amount: 1, unit: "days" },
+            to: { amount: -1, unit: "days" },
+          },
+        },
+        min: "2026-02-01",
+        max: "2026-01-30",
+      },
+      {
+        name: "dynamic limits tighten dynamic between",
+        restrictions: {
+          min_date: { mode: "dynamic", amount: -1, unit: "days" },
+          max_date: { mode: "dynamic", amount: 1, unit: "days" },
+          between: {
+            mode: "dynamic",
+            from: { amount: -1, unit: "weeks" },
+            to: { amount: 1, unit: "weeks" },
+          },
+        },
+        min: "2026-01-30",
+        max: "2026-02-01",
+      },
+    ])("$name", ({ now = NOW, restrictions, min, max }) => {
+      expect(resolveRestrictions(restrictions, type, new Date(now))).toEqual({
+        min: min && (type === "datetime" ? `${min}T00:00` : min),
+        max: max && (type === "datetime" ? `${max}T23:59` : max),
+      });
+    });
+  });
+
+  describe("invalid relative bounds", () => {
+    it.each([
+      ["fractional number", 1.5],
+      ["fractional string", "1.5"],
+      ["non-numeric string", "invalid"],
+      ["empty string", ""],
+      ["null", null],
+      ["missing amount", undefined],
+      ["boolean", true],
+    ])("leaves %s amounts open on either side", (_name, amount) => {
+      expect(
+        resolveRestrictions(
+          {
+            min_date: { mode: "dynamic", amount, unit: "days" },
+            max_date: { mode: "dynamic", amount, unit: "months" },
+          },
+          type,
+          new Date(NOW),
+        ),
+      ).toEqual({ min: undefined, max: undefined });
+    });
+
+    it("leaves an unsupported unit open without discarding a valid sibling", () => {
+      expect(
+        resolveRestrictions(
+          {
+            between: {
+              mode: "dynamic",
+              from: { amount: -1, unit: "hours" },
+              to: { amount: 1, unit: "days" },
+            },
+          },
+          type,
+          new Date(NOW),
+        ),
+      ).toEqual({
+        min: undefined,
+        max: type === "date" ? "2026-02-01" : "2026-02-01T23:59",
+      });
+    });
+  });
+
+  describe("default clock", () => {
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it("uses the frozen clock when now is omitted", () => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date(NOW));
+
+      expect(
+        resolveRestrictions(
+          { min_date: { mode: "dynamic", amount: 1, unit: "days" } },
+          type,
+        ),
+      ).toEqual({
+        min: type === "date" ? "2026-01-30" : "2026-01-30T00:00",
+        max: undefined,
+      });
+    });
+  });
+});
+
+describe("resolveRestrictions field types and datetime precision", () => {
+  it("leaves unsupported field types open even with valid restrictions", () => {
+    expect(
+      resolveRestrictions(
+        { min_date: { mode: "static", value: "2026-02-01" } },
+        "string",
+        new Date(NOW),
+      ),
+    ).toEqual({ min: undefined, max: undefined });
+  });
+
+  it.each([
+    ["date", { min: "2026-02-01", max: "2026-02-02" }],
+    ["datetime", { min: "2026-02-01T10:15", max: "2026-02-02T18:45" }],
+  ])("formats explicit timestamps at %s precision", (type, expected) => {
+    expect(
+      resolveRestrictions(
+        {
+          min_date: { mode: "static", value: "2026-02-01T10:15:59.999Z" },
+          max_date: { mode: "static", value: "2026-02-02T18:45:30Z" },
+        },
+        type,
+        new Date(NOW),
+      ),
+    ).toEqual(expected);
+  });
+
+  it("intersects a date-only range with minute-precision datetime limits", () => {
+    expect(
+      resolveRestrictions(
+        {
+          min_date: { mode: "static", value: "2026-02-01T10:15" },
+          max_date: { mode: "static", value: "2026-02-02T18:45" },
+          between: { mode: "static", start: "2026-02-01", end: "2026-02-02" },
+        },
+        "datetime",
+        new Date(NOW),
+      ),
+    ).toEqual({ min: "2026-02-01T10:15", max: "2026-02-02T18:45" });
+  });
+});
+
+describe("datetime-local restrictions in the host timezone", () => {
+  it("preserves static local datetime components without a timezone shift", () => {
+    expect(
+      resolveRestrictions(
+        {
+          min_date: { mode: "static", value: "2026-10-05T18:30" },
+          max_date: { mode: "static", value: "2026-10-05T20:45" },
+        },
+        "datetime",
+      ),
+    ).toEqual({ min: "2026-10-05T18:30", max: "2026-10-05T20:45" });
+  });
+
+  it.each([
+    [1, 23, "2026-10-12T23:59"],
+    [23, 10, "2026-10-12T23:59"],
+  ])(
+    "resolves a two-day relative maximum to the end of the calendar day at %s:%s",
+    (hours, minutes, expected) => {
+      const now = new Date(2026, 9, 10, hours, minutes);
+
+      expect(
+        resolveRestrictions(
+          { max_date: { mode: "dynamic", amount: 2, unit: "days" } },
+          "datetime",
+          now,
+        ),
+      ).toEqual({ min: undefined, max: expected });
+    },
+  );
+
+  it("uses the start and end of the days in a relative range", () => {
+    expect(
+      resolveRestrictions(
+        {
+          between: {
+            mode: "dynamic",
+            from: { amount: -2, unit: "days" },
+            to: { amount: 2, unit: "days" },
+          },
+        },
+        "datetime",
+        new Date(2026, 9, 10, 23, 10),
+      ),
+    ).toEqual({ min: "2026-10-08T00:00", max: "2026-10-12T23:59" });
+  });
+
+  it("shifts calendar days across the autumn DST transition", () => {
+    expect(
+      resolveRestrictions(
+        { max_date: { mode: "dynamic", amount: 2, unit: "days" } },
+        "datetime",
+        new Date(2026, 9, 24, 23, 10),
+      ),
+    ).toEqual({ min: undefined, max: "2026-10-26T23:59" });
+  });
+
+  it("shifts calendar days across the spring DST transition", () => {
+    expect(
+      resolveRestrictions(
+        { max_date: { mode: "dynamic", amount: 1, unit: "days" } },
+        "datetime",
+        new Date(2026, 2, 28, 23, 10),
+      ),
+    ).toEqual({ min: undefined, max: "2026-03-29T23:59" });
+  });
+});
+
+describe("strict ISO date values and bounds", () => {
+  it.each([
+    ["date", "2027-01-01T00:00:00Z", "2026-01-01", "2026-12-31", "too_late"],
+    ["date", "2025-12-31T23:59:59+05:00", "2026-01-01", undefined, "too_early"],
+    [
+      "date",
+      "2025-12-31T23:59:59+05:00",
+      "2026-01-01",
+      "2026-01-01",
+      "too_early",
+    ],
+    ["date", "2026-06-15T11:30:45.123+02:00", "2026-06-15", "2026-06-15", "ok"],
+    [
+      "datetime",
+      "2027-01-01T00:00:00Z",
+      undefined,
+      "2026-12-31T23:59",
+      "too_late",
+    ],
+    [
+      "datetime",
+      "2025-12-31T23:30:00+02:00",
+      "2026-01-01T00:00",
+      undefined,
+      "too_early",
+    ],
+    [
+      "datetime",
+      "2026-06-15T10:00:59.999Z",
+      "2026-06-15T10:00",
+      "2026-06-15T10:00",
+      "ok",
+    ],
+  ])(
+    "compares %s value %s at the bounds' precision",
+    (_type, value, min, max, expected) => {
+      expect(compareToLimits(value, min, max)).toBe(expected);
+    },
+  );
+
+  it.each([
+    "2026-02-30",
+    "2025-02-29",
+    "2026-13-01",
+    "2026-06-15T24:00:00Z",
+    "2026-06-15T10:61:00Z",
+    "2026-06-15T10:00:00+25:00",
+    "2026-06-15T10:00:00+14:30",
+    "2026-06-15T10:00:00+01:60",
+  ])("rejects impossible or malformed complete date %s", (value) => {
+    expect(compareToLimits(value, "2026-01-01", "2026-12-31")).toBe(
+      "invalid_date",
+    );
+  });
+
+  it.each([
+    "",
+    "2026-",
+    "2026-0",
+    "2026-06-",
+    "2026-06-15T",
+    "2026-06-15T1",
+    "2026-06-15T10:00:00.",
+  ])("leaves partial user input %s for the browser to complete", (value) => {
+    expect(compareToLimits(value, "2026-01-01", "2026-12-31")).toBe("ok");
+  });
+
+  it("reports invalid values before checking their position against bounds", () => {
+    expect(
+      checkValuesAgainstBounds("2026-02-30", {
+        min: "2026-01-01",
+        max: "2026-12-31",
+      }),
+    ).toBe("invalid_date");
+  });
+
+  it("accepts an invalid date value when no bounds apply", () => {
+    expect(compareToLimits("2026-02-30", undefined, undefined)).toBe("ok");
+  });
+});

package/src/templates/utils/__tests__/originalTableRows.spec.js

@@ -0,0 +1,129 @@
+import { copyRow, getOriginalRow, markNewRow } from "../originalTableRows";
+import { applyTemplate, applyTemplateWithoutDefaults } from "../applyTemplate";
+import { validateContent } from "../validateContent";
+
+const cell = (value) => ({ value, origin: "user" });
+const row = (value) => ({ date: cell(value), sibling: cell("old") });
+const date = {
+  name: "date",
+  type: "date",
+  restrictions: { resolved: { min: "2026-01-01", max: "2026-12-31" } },
+};
+const table = {
+  name: "table",
+  type: "dynamic_table",
+  values: { table_columns: [date, { name: "sibling", type: "string" }] },
+};
+const template = { content: [{ name: "group", fields: [table] }] };
+const content = (rows) => ({ table: cell(rows) });
+
+describe("original table row lineage", () => {
+  it.each([null, undefined, "legacy", 0])(
+    "does not cache a non-object row (%j)",
+    (value) => {
+      expect(getOriginalRow(value, 0, [])).toBeUndefined();
+    },
+  );
+
+  it("tolerates a null legacy table row during edit validation", () => {
+    expect(
+      validateContent(template, content([row("2025-01-01")]))(content([null])),
+    ).toEqual([]);
+  });
+
+  it("keeps an untracked original survivor associated by identity", () => {
+    const original = [row("2025-01-01"), row("2024-01-01")];
+    expect(
+      validateContent(template, content(original))(content(original.slice(1))),
+    ).toEqual([]);
+  });
+
+  it("preserves a seeded cloned survivor after the first row is removed", () => {
+    const original = [row("2025-01-01"), row("2024-01-01")];
+    const rows = original.map((value, index) => {
+      const cloned = { ...value };
+      getOriginalRow(cloned, index, original);
+      return cloned;
+    });
+    expect(
+      validateContent(template, content(original))(content(rows.slice(1))),
+    ).toEqual([]);
+  });
+
+  it.each([applyTemplate, applyTemplateWithoutDefaults])(
+    "retains a survivor baseline through sibling edits and complete normalization (%#)",
+    (normalize) => {
+      const original = [row("2025-01-01"), row("2024-01-01")];
+      const survivor = { ...original[1] };
+      getOriginalRow(survivor, 1, original);
+      const edited = copyRow(survivor, {
+        ...survivor,
+        sibling: cell("edited"),
+      });
+      const normalized = normalize(template)(content([edited]));
+      expect(validateContent(template, content(original))(normalized)).toEqual(
+        [],
+      );
+    },
+  );
+
+  it.each([applyTemplate, applyTemplateWithoutDefaults])(
+    "never exempts a new row at a deleted row's reused index after normalization (%#)",
+    (normalize) => {
+      const original = [row("2025-01-01")];
+      const added = markNewRow({});
+      const edited = copyRow(added, row("2025-01-01"));
+      const normalized = normalize(template)(content([edited]));
+      expect(validateContent(template, content(original))(normalized)).toEqual([
+        {
+          error: "date out of range",
+          field: "table.0.date",
+          values: date.restrictions.resolved,
+        },
+      ]);
+    },
+  );
+
+  it("scopes a shared row's baselines to each language or edit session", () => {
+    const shared = row("2025-01-01");
+    const english = [row("2025-01-01")];
+    const spanish = [row("2024-01-01")];
+    getOriginalRow(shared, 0, english);
+    getOriginalRow(shared, 0, spanish);
+    expect(getOriginalRow(shared, 4, english)).toBe(english[0]);
+    expect(getOriginalRow(shared, 4, spanish)).toBe(spanish[0]);
+  });
+
+  it("keeps the new-row marker universal across baseline scopes", () => {
+    const added = markNewRow(row("2025-01-01"));
+    expect(getOriginalRow(added, 0, [row("2025-01-01")])).toBeUndefined();
+    expect(getOriginalRow(added, 0, [row("2025-01-01")])).toBeUndefined();
+  });
+
+  it("retains nested row lineage through outer and inner removals and normalization", () => {
+    const nestedTable = { ...table, name: "nested" };
+    const nestedTemplate = {
+      content: [
+        {
+          name: "group",
+          fields: [{ ...table, values: { table_columns: [nestedTable] } }],
+        },
+      ],
+    };
+    const original = [
+      { nested: cell([row("2023-01-01")]) },
+      { nested: cell([row("2025-01-01"), row("2024-01-01")]) },
+    ];
+    const outer = { ...original[1] };
+    getOriginalRow(outer, 1, original);
+    const inner = { ...original[1].nested.value[1] };
+    getOriginalRow(inner, 1, original[1].nested.value);
+    const edited = copyRow(outer, {
+      nested: cell([copyRow(inner, { ...inner, sibling: cell("edited") })]),
+    });
+    const normalized = applyTemplate(nestedTemplate)(content([edited]));
+    expect(
+      validateContent(nestedTemplate, content(original))(normalized),
+    ).toEqual([]);
+  });
+});