@intlayer/cli 5.5.10 → 5.5.11

package/dist/cjs/utils/checkFileModifiedRange.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var checkFileModifiedRange_exports = {};
+__export(checkFileModifiedRange_exports, {
+  checkFileModifiedRange: () => checkFileModifiedRange
+});
+module.exports = __toCommonJS(checkFileModifiedRange_exports);
+var import_checkLastUpdateTime = require('./checkLastUpdateTime.cjs');
+var import_formatTimeDiff = require('./formatTimeDiff.cjs');
+const TIMESTAMP_THRESHOLD_MS = 50 * 365 * 24 * 60 * 60 * 1e3;
+const normaliseInputDate = (date, now = /* @__PURE__ */ new Date()) => {
+  if (date instanceof Date) {
+    return {
+      absoluteTime: date,
+      relativeTime: new Date(now.getTime() - date.getTime())
+    };
+  }
+  if (typeof date === "number") {
+    if (date > TIMESTAMP_THRESHOLD_MS) {
+      const absoluteTime = new Date(date);
+      return {
+        absoluteTime,
+        relativeTime: new Date(now.getTime() - absoluteTime.getTime())
+      };
+    }
+    const relativeMs = date;
+    return {
+      // Relative duration expressed as a Date object starting at the epoch
+      relativeTime: new Date(relativeMs),
+      // The concrete date obtained by subtracting the duration from *now*
+      absoluteTime: new Date(now.getTime() - relativeMs)
+    };
+  }
+  if (typeof date === "string") {
+    const absoluteTime = new Date(date);
+    if (Number.isNaN(absoluteTime.getTime())) {
+      throw new Error(`Invalid date string provided: ${date}`);
+    }
+    return {
+      absoluteTime,
+      relativeTime: new Date(now.getTime() - absoluteTime.getTime())
+    };
+  }
+  throw new Error(`Unsupported date format: ${date}`);
+};
+const checkFileModifiedRange = (filePath, options) => {
+  const fileLastUpdateTime = (0, import_checkLastUpdateTime.checkLastUpdateTime)(filePath);
+  const { skipIfModifiedBefore, skipIfModifiedAfter } = options;
+  const now = /* @__PURE__ */ new Date();
+  const minDate = skipIfModifiedBefore ? normaliseInputDate(skipIfModifiedBefore, now).absoluteTime : void 0;
+  const maxDate = skipIfModifiedAfter ? normaliseInputDate(skipIfModifiedAfter, now).absoluteTime : void 0;
+  let shouldSkip = false;
+  if (minDate instanceof Date && maxDate instanceof Date) {
+    shouldSkip = fileLastUpdateTime >= minDate && fileLastUpdateTime <= maxDate;
+  } else if (minDate instanceof Date) {
+    shouldSkip = fileLastUpdateTime >= minDate;
+  } else if (maxDate) {
+    shouldSkip = fileLastUpdateTime >= maxDate;
+  }
+  if (shouldSkip) {
+    const referenceDate = minDate && maxDate ? (
+      // When both bounds are present, the *range* caused the skip so we use
+      // the distance between the two bounds as the relative duration.
+      new Date(Math.abs(maxDate.getTime() - minDate.getTime()))
+    ) : minDate ?? maxDate;
+    const relativeTime = new Date(now.getTime() - referenceDate.getTime());
+    return {
+      isSkipped: true,
+      message: `Skipping file because it has been modified within the last ${(0, import_formatTimeDiff.formatTimeDiff)(relativeTime)} - ${filePath}`
+    };
+  }
+  return {
+    isSkipped: false,
+    message: `File ${filePath} can be processed - ${filePath}`
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkFileModifiedRange
+});
+//# sourceMappingURL=checkFileModifiedRange.cjs.map

package/dist/cjs/utils/checkFileModifiedRange.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/checkFileModifiedRange.ts"],"sourcesContent":["import { checkLastUpdateTime } from './checkLastUpdateTime';\nimport { formatTimeDiff } from './formatTimeDiff';\n\ntype GetTimeRangeResult = {\n  relativeTime: Date;\n  absoluteTime: Date;\n};\n\n/**\n * Threshold that helps us differentiate between a numeric *timestamp* (ms from epoch)\n * and a numeric *duration* (ms ago).\n * 50 years expressed in milliseconds is far greater than any reasonable\n * \"relative\" duration we expect the helper to receive (e.g. a couple of years).\n */\nconst TIMESTAMP_THRESHOLD_MS = 50 * 365 * 24 * 60 * 60 * 1000; // 50 years\n\n/**\n * Normalises the input date representation into a pair:\n *   1. `relativeTime` – a Date instance whose epoch-time equals the duration\n *      between `now` and the absolute date.\n *   2. `absoluteTime` – the concrete point in time represented as a Date.\n *\n * Rules for interpreting the input:\n *   • Date  => treated as an absolute time.\n *   • string => parsed via the Date constructor => absolute time.\n *   • number:\n *       – if the value is larger than the TIMESTAMP_THRESHOLD_MS we assume it\n *         is a unix timestamp (absolute time).\n *       – otherwise we treat it as a *relative* duration expressed in\n *         milliseconds.\n */\nconst normaliseInputDate = (\n  date: Date | number | string,\n  now: Date = new Date()\n): GetTimeRangeResult => {\n  // Case 1: Already a Date instance\n  if (date instanceof Date) {\n    return {\n      absoluteTime: date,\n      relativeTime: new Date(now.getTime() - date.getTime()),\n    };\n  }\n\n  // Case 2: Numeric value – decide between timestamp vs relative ms.\n  if (typeof date === 'number') {\n    if (date > TIMESTAMP_THRESHOLD_MS) {\n      // Treat as *unix timestamp* (absolute)\n      const absoluteTime = new Date(date);\n      return {\n        absoluteTime,\n        relativeTime: new Date(now.getTime() - absoluteTime.getTime()),\n      };\n    }\n\n    // Treat as a *relative* duration (milliseconds in the past)\n    const relativeMs = date;\n    return {\n      // Relative duration expressed as a Date object starting at the epoch\n      relativeTime: new Date(relativeMs),\n      // The concrete date obtained by subtracting the duration from *now*\n      absoluteTime: new Date(now.getTime() - relativeMs),\n    };\n  }\n\n  // Case 3: String representation – let Date parse it.\n  if (typeof date === 'string') {\n    const absoluteTime = new Date(date);\n    if (Number.isNaN(absoluteTime.getTime())) {\n      throw new Error(`Invalid date string provided: ${date}`);\n    }\n\n    return {\n      absoluteTime,\n      relativeTime: new Date(now.getTime() - absoluteTime.getTime()),\n    };\n  }\n\n  throw new Error(`Unsupported date format: ${date}`);\n};\n\ntype CheckFileModifiedRangeResult = {\n  isSkipped: boolean;\n  message: string;\n};\n\ntype CheckFileModifiedRangeOptions = {\n  skipIfModifiedBefore?: Date | number | string;\n  skipIfModifiedAfter?: Date | number | string;\n};\n\nexport const checkFileModifiedRange = (\n  filePath: string,\n  options: CheckFileModifiedRangeOptions\n): CheckFileModifiedRangeResult => {\n  const fileLastUpdateTime = checkLastUpdateTime(filePath);\n  const { skipIfModifiedBefore, skipIfModifiedAfter } = options;\n\n  // Normalise the provided thresholds to concrete dates.\n  const now = new Date();\n  const minDate = skipIfModifiedBefore\n    ? normaliseInputDate(skipIfModifiedBefore, now).absoluteTime\n    : undefined;\n  const maxDate = skipIfModifiedAfter\n    ? normaliseInputDate(skipIfModifiedAfter, now).absoluteTime\n    : undefined;\n\n  // Determine if the file should be skipped.\n  let shouldSkip = false;\n\n  if (minDate instanceof Date && maxDate instanceof Date) {\n    // Skip when the modification time falls *within* the range [minDate, maxDate]\n    shouldSkip = fileLastUpdateTime >= minDate && fileLastUpdateTime <= maxDate;\n  } else if (minDate instanceof Date) {\n    // Only lower bound – skip when the file was modified *after* minDate\n    shouldSkip = fileLastUpdateTime >= minDate;\n  } else if (maxDate) {\n    // Only upper bound – skip when the file was modified *after* maxDate\n    shouldSkip = fileLastUpdateTime >= maxDate;\n  }\n\n  if (shouldSkip) {\n    // For the sake of the message we compute the relative time to *now* using\n    // whichever bound was responsible for the skip logic.\n    const referenceDate = (\n      minDate && maxDate\n        ? // When both bounds are present, the *range* caused the skip so we use\n          // the distance between the two bounds as the relative duration.\n          new Date(Math.abs(maxDate.getTime() - minDate.getTime()))\n        : (minDate ?? maxDate)\n    )!;\n\n    const relativeTime = new Date(now.getTime() - referenceDate.getTime());\n\n    return {\n      isSkipped: true,\n      message: `Skipping file because it has been modified within the last ${formatTimeDiff(relativeTime)} - ${filePath}`,\n    };\n  }\n\n  return {\n    isSkipped: false,\n    message: `File ${filePath} can be processed - ${filePath}`,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAAoC;AACpC,4BAA+B;AAa/B,MAAM,yBAAyB,KAAK,MAAM,KAAK,KAAK,KAAK;AAiBzD,MAAM,qBAAqB,CACzB,MACA,MAAY,oBAAI,KAAK,MACE;AAEvB,MAAI,gBAAgB,MAAM;AACxB,WAAO;AAAA,MACL,cAAc;AAAA,MACd,cAAc,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,QAAQ,CAAC;AAAA,IACvD;AAAA,EACF;AAGA,MAAI,OAAO,SAAS,UAAU;AAC5B,QAAI,OAAO,wBAAwB;AAEjC,YAAM,eAAe,IAAI,KAAK,IAAI;AAClC,aAAO;AAAA,QACL;AAAA,QACA,cAAc,IAAI,KAAK,IAAI,QAAQ,IAAI,aAAa,QAAQ,CAAC;AAAA,MAC/D;AAAA,IACF;AAGA,UAAM,aAAa;AACnB,WAAO;AAAA;AAAA,MAEL,cAAc,IAAI,KAAK,UAAU;AAAA;AAAA,MAEjC,cAAc,IAAI,KAAK,IAAI,QAAQ,IAAI,UAAU;AAAA,IACnD;AAAA,EACF;AAGA,MAAI,OAAO,SAAS,UAAU;AAC5B,UAAM,eAAe,IAAI,KAAK,IAAI;AAClC,QAAI,OAAO,MAAM,aAAa,QAAQ,CAAC,GAAG;AACxC,YAAM,IAAI,MAAM,iCAAiC,IAAI,EAAE;AAAA,IACzD;AAEA,WAAO;AAAA,MACL;AAAA,MACA,cAAc,IAAI,KAAK,IAAI,QAAQ,IAAI,aAAa,QAAQ,CAAC;AAAA,IAC/D;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,4BAA4B,IAAI,EAAE;AACpD;AAYO,MAAM,yBAAyB,CACpC,UACA,YACiC;AACjC,QAAM,yBAAqB,gDAAoB,QAAQ;AACvD,QAAM,EAAE,sBAAsB,oBAAoB,IAAI;AAGtD,QAAM,MAAM,oBAAI,KAAK;AACrB,QAAM,UAAU,uBACZ,mBAAmB,sBAAsB,GAAG,EAAE,eAC9C;AACJ,QAAM,UAAU,sBACZ,mBAAmB,qBAAqB,GAAG,EAAE,eAC7C;AAGJ,MAAI,aAAa;AAEjB,MAAI,mBAAmB,QAAQ,mBAAmB,MAAM;AAEtD,iBAAa,sBAAsB,WAAW,sBAAsB;AAAA,EACtE,WAAW,mBAAmB,MAAM;AAElC,iBAAa,sBAAsB;AAAA,EACrC,WAAW,SAAS;AAElB,iBAAa,sBAAsB;AAAA,EACrC;AAEA,MAAI,YAAY;AAGd,UAAM,gBACJ,WAAW;AAAA;AAAA;AAAA,MAGP,IAAI,KAAK,KAAK,IAAI,QAAQ,QAAQ,IAAI,QAAQ,QAAQ,CAAC,CAAC;AAAA,QACvD,WAAW;AAGlB,UAAM,eAAe,IAAI,KAAK,IAAI,QAAQ,IAAI,cAAc,QAAQ,CAAC;AAErE,WAAO;AAAA,MACL,WAAW;AAAA,MACX,SAAS,kEAA8D,sCAAe,YAAY,CAAC,MAAM,QAAQ;AAAA,IACnH;AAAA,EACF;AAEA,SAAO;AAAA,IACL,WAAW;AAAA,IACX,SAAS,QAAQ,QAAQ,uBAAuB,QAAQ;AAAA,EAC1D;AACF;","names":[]}

package/dist/cjs/utils/checkFileModifiedRange.test.cjs

@@ -0,0 +1,175 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_checkFileModifiedRange = require('./checkFileModifiedRange.cjs');
+var import_checkLastUpdateTime = require('./checkLastUpdateTime.cjs');
+import_vitest.vi.mock("./checkLastUpdateTime", () => {
+  return {
+    checkLastUpdateTime: import_vitest.vi.fn(() => /* @__PURE__ */ new Date())
+    // pretend the file was just modified
+  };
+});
+(0, import_vitest.describe)("checkFileModifiedRange", () => {
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+    import_vitest.vi.setSystemTime(/* @__PURE__ */ new Date("2025-01-01"));
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.useRealTimers();
+    import_vitest.vi.clearAllMocks();
+  });
+  const testList = [
+    {
+      // |---a---|
+      fileModifiedTime: /* @__PURE__ */ new Date("2025-01-01"),
+      // a
+      isSkipped: false
+      // No constraints
+    },
+    {
+      // |-min-a-max-|
+      skipIfModifiedBefore: "2024-01-01",
+      // min
+      skipIfModifiedAfter: "2026-01-01",
+      // max
+      fileModifiedTime: /* @__PURE__ */ new Date("2025-01-01"),
+      // a
+      isSkipped: true
+      // During the range
+    },
+    {
+      // |-min-max-a-|
+      skipIfModifiedBefore: "2024-01-01",
+      // min
+      skipIfModifiedAfter: "2026-01-01",
+      // max
+      fileModifiedTime: /* @__PURE__ */ new Date("2027-01-01"),
+      // a
+      isSkipped: false
+      // After the range
+    },
+    {
+      // |-a-min-max-|
+      skipIfModifiedBefore: "2024-01-01",
+      // min
+      skipIfModifiedAfter: "2026-01-01",
+      // max
+      fileModifiedTime: /* @__PURE__ */ new Date("2023-01-01"),
+      // a
+      isSkipped: false
+      // Before the range
+    },
+    {
+      // |-a-min-|
+      skipIfModifiedBefore: "2024-01-01",
+      // min
+      fileModifiedTime: /* @__PURE__ */ new Date("2023-01-01"),
+      // a
+      isSkipped: false
+      // Before the skipIfModifiedBefore
+    },
+    {
+      // |-min-a-|
+      skipIfModifiedBefore: "2024-01-01",
+      // min
+      fileModifiedTime: /* @__PURE__ */ new Date("2025-01-01"),
+      // a
+      isSkipped: true
+      // After the skipIfModifiedBefore
+    },
+    {
+      // |-a-max-|
+      skipIfModifiedAfter: "2026-01-01",
+      // max
+      fileModifiedTime: /* @__PURE__ */ new Date("2027-01-01"),
+      // a
+      isSkipped: true
+      // Before the skipIfModifiedAfter
+    },
+    {
+      // |-max-a-|
+      skipIfModifiedAfter: "2026-01-01",
+      // max
+      fileModifiedTime: /* @__PURE__ */ new Date("2027-01-01"),
+      // a
+      isSkipped: true
+      // After the skipIfModifiedAfter
+    },
+    {
+      // |-min-max-a-|
+      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1e3,
+      // min // 3 year ago
+      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1e3,
+      // max // 1 year
+      fileModifiedTime: /* @__PURE__ */ new Date("2025-01-01"),
+      // a
+      isSkipped: false
+      // Before the range
+    },
+    {
+      // |-a-max-|
+      skipIfModifiedAfter: 0,
+      // max // now
+      fileModifiedTime: /* @__PURE__ */ new Date("2024-01-01"),
+      // a
+      isSkipped: false
+      // Before the skipIfModifiedAfter
+    },
+    {
+      // |-min-a-|
+      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1e3,
+      // max // 1 year
+      fileModifiedTime: /* @__PURE__ */ new Date("2025-01-01"),
+      // a
+      isSkipped: true
+      // Before the skipIfModifiedAfter
+    },
+    {
+      // |-min-a-max-|
+      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1e3,
+      // min // 3 year ago
+      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1e3,
+      // max // 1 year
+      fileModifiedTime: /* @__PURE__ */ new Date("2023-01-01"),
+      // a
+      isSkipped: true
+      // After the range
+    },
+    {
+      // |-a-min-max-|
+      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1e3,
+      // min // 3 year ago
+      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1e3,
+      // max // 1 year
+      fileModifiedTime: /* @__PURE__ */ new Date("2020-01-01"),
+      // a
+      isSkipped: false
+      // Before the range
+    },
+    {
+      // |-min-max-a-|
+      skipIfModifiedBefore: "2024-01-01T00:00:00Z",
+      // min
+      skipIfModifiedAfter: "2026-01-01T00:00:00Z",
+      // max
+      fileModifiedTime: /* @__PURE__ */ new Date("2027-01-01"),
+      // a
+      isSkipped: false
+      // After the range
+    }
+  ];
+  testList.forEach((test) => {
+    (0, import_vitest.it)(`should correctly handle string date inputs (absolute time) outside of the range`, () => {
+      const filePath = "test/file.txt";
+      import_checkLastUpdateTime.checkLastUpdateTime.mockReturnValue(
+        // If a specific mocked modification time is provided, use it. Otherwise, fall back to "now".
+        test.fileModifiedTime ?? /* @__PURE__ */ new Date()
+      );
+      const { isSkipped } = (0, import_checkFileModifiedRange.checkFileModifiedRange)(filePath, {
+        skipIfModifiedBefore: test.skipIfModifiedBefore,
+        skipIfModifiedAfter: test.skipIfModifiedAfter
+      });
+      (0, import_vitest.expect)(isSkipped).toBe(test.isSkipped);
+    });
+  });
+});
+//# sourceMappingURL=checkFileModifiedRange.test.cjs.map

package/dist/cjs/utils/checkFileModifiedRange.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/checkFileModifiedRange.test.ts"],"sourcesContent":["import {\n  afterEach,\n  beforeEach,\n  describe,\n  expect,\n  it,\n  vi,\n  type Mock,\n} from 'vitest';\n\n// We are testing the public helper. The helper itself internally relies on\n// `checkLastUpdateTime`, which hits the file-system. To keep the test\n// deterministic (and independent from the real FS) we mock this dependency so\n// that we can control the last modification date that the helper receives.\n\n// NOTE: `vi.mock` must be called *before* the module under test is imported.\nvi.mock('./checkLastUpdateTime', () => {\n  return {\n    checkLastUpdateTime: vi.fn(() => new Date()), // pretend the file was just modified\n  };\n});\n\nimport { checkFileModifiedRange } from './checkFileModifiedRange';\nimport { checkLastUpdateTime } from './checkLastUpdateTime';\n\ndescribe('checkFileModifiedRange', () => {\n  beforeEach(() => {\n    // Use fake timers so Date.now() is deterministic.\n    vi.useFakeTimers();\n    // Pin the system time to an arbitrary date for reproducibility\n    vi.setSystemTime(new Date('2025-01-01'));\n  });\n\n  afterEach(() => {\n    vi.useRealTimers();\n    vi.clearAllMocks();\n  });\n\n  const testList = [\n    {\n      // |---a---|\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: false, // No constraints\n    },\n    {\n      // |-min-a-max-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: true, // During the range\n    },\n    {\n      // |-min-max-a-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: false, // After the range\n    },\n    {\n      // |-a-min-max-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2023-01-01'), // a\n      isSkipped: false, // Before the range\n    },\n    {\n      // |-a-min-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      fileModifiedTime: new Date('2023-01-01'), // a\n      isSkipped: false, // Before the skipIfModifiedBefore\n    },\n    {\n      // |-min-a-|\n      skipIfModifiedBefore: '2024-01-01', // min\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: true, // After the skipIfModifiedBefore\n    },\n    {\n      // |-a-max-|\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: true, // Before the skipIfModifiedAfter\n    },\n    {\n      // |-max-a-|\n      skipIfModifiedAfter: '2026-01-01', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: true, // After the skipIfModifiedAfter\n    },\n    {\n      // |-min-max-a-|\n      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1000, // min // 3 year ago\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: false, // Before the range\n    },\n    {\n      // |-a-max-|\n      skipIfModifiedAfter: 0, // max // now\n      fileModifiedTime: new Date('2024-01-01'), // a\n      isSkipped: false, // Before the skipIfModifiedAfter\n    },\n    {\n      // |-min-a-|\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2025-01-01'), // a\n      isSkipped: true, // Before the skipIfModifiedAfter\n    },\n    {\n      // |-min-a-max-|\n      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1000, // min // 3 year ago\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2023-01-01'), // a\n      isSkipped: true, // After the range\n    },\n    {\n      // |-a-min-max-|\n      skipIfModifiedBefore: 3 * 365 * 24 * 60 * 60 * 1000, // min // 3 year ago\n      skipIfModifiedAfter: 1 * 365 * 24 * 60 * 60 * 1000, // max // 1 year\n      fileModifiedTime: new Date('2020-01-01'), // a\n      isSkipped: false, // Before the range\n    },\n    {\n      // |-min-max-a-|\n      skipIfModifiedBefore: '2024-01-01T00:00:00Z', // min\n      skipIfModifiedAfter: '2026-01-01T00:00:00Z', // max\n      fileModifiedTime: new Date('2027-01-01'), // a\n      isSkipped: false, // After the range\n    },\n  ];\n\n  testList.forEach((test) => {\n    it(`should correctly handle string date inputs (absolute time) outside of the range`, () => {\n      const filePath = 'test/file.txt';\n\n      // Simulate the file's last modification time for this test case\n      (checkLastUpdateTime as unknown as Mock).mockReturnValue(\n        // If a specific mocked modification time is provided, use it. Otherwise, fall back to \"now\".\n        test.fileModifiedTime ?? new Date()\n      );\n\n      const { isSkipped } = checkFileModifiedRange(filePath, {\n        skipIfModifiedBefore: test.skipIfModifiedBefore,\n        skipIfModifiedAfter: test.skipIfModifiedAfter,\n      });\n\n      expect(isSkipped).toBe(test.isSkipped);\n    });\n  });\n});\n"],"mappings":"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","names":[]}

package/dist/cjs/utils/checkLastUpdateTime.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var checkLastUpdateTime_exports = {};
+__export(checkLastUpdateTime_exports, {
+  checkLastUpdateTime: () => checkLastUpdateTime
+});
+module.exports = __toCommonJS(checkLastUpdateTime_exports);
+var import_fs = require("fs");
+const checkLastUpdateTime = (filePath) => {
+  const stats = (0, import_fs.statSync)(filePath);
+  return new Date(stats.mtime);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkLastUpdateTime
+});
+//# sourceMappingURL=checkLastUpdateTime.cjs.map

package/dist/cjs/utils/checkLastUpdateTime.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/checkLastUpdateTime.ts"],"sourcesContent":["import { statSync } from 'fs';\n\n/**\n * Returns the last modification date of a file.\n *\n * @param filePath - Absolute or relative path to the file to inspect.\n * @returns Date instance representing the file's last modified time (mtime).\n * @throws Will propagate any error thrown by fs.statSync (e.g., file not found).\n */\nexport const checkLastUpdateTime = (filePath: string): Date => {\n  const stats = statSync(filePath);\n  return new Date(stats.mtime);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAAyB;AASlB,MAAM,sBAAsB,CAAC,aAA2B;AAC7D,QAAM,YAAQ,oBAAS,QAAQ;AAC/B,SAAO,IAAI,KAAK,MAAM,KAAK;AAC7B;","names":[]}

package/dist/cjs/utils/chunkInference.cjs

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunkInference_exports = {};
+__export(chunkInference_exports, {
+  chunkInference: () => chunkInference
+});
+module.exports = __toCommonJS(chunkInference_exports);
+var import_api = require("@intlayer/api");
+var import_config = require("@intlayer/config");
+const chunkInference = async (messages, aiOptions, oAuth2AccessToken) => {
+  let lastResult;
+  await (0, import_config.retryManager)(async () => {
+    const response = await (0, import_api.getAiAPI)().customQuery(
+      {
+        aiOptions,
+        messages
+      },
+      {
+        ...oAuth2AccessToken && {
+          headers: {
+            Authorization: `Bearer ${oAuth2AccessToken}`
+          }
+        }
+      }
+    );
+    if (!response.data) {
+      throw new Error("No response from AI API");
+    }
+    const { fileContent, tokenUsed } = response.data;
+    const newContent = fileContent.replaceAll("///chunksStart///", "").replaceAll("///chunkStart///", "").replaceAll("///chunksEnd///", "").replaceAll("///chunkEnd///", "");
+    lastResult = {
+      fileContent: newContent,
+      tokenUsed
+    };
+  })();
+  return lastResult;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chunkInference
+});
+//# sourceMappingURL=chunkInference.cjs.map

package/dist/cjs/utils/chunkInference.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/chunkInference.ts"],"sourcesContent":["import { type AIOptions, type Messages, getAiAPI } from '@intlayer/api';\nimport { retryManager } from '@intlayer/config';\n\ntype ChunkInferenceResult = {\n  fileContent: string;\n  tokenUsed: number;\n};\n\n/**\n * Translates a single chunk via the OpenAI API.\n * Includes retry logic if the call fails.\n */\nexport const chunkInference = async (\n  messages: Messages,\n  aiOptions?: AIOptions,\n  oAuth2AccessToken?: string\n): Promise<ChunkInferenceResult> => {\n  let lastResult: ChunkInferenceResult;\n\n  await retryManager(async () => {\n    const response = await getAiAPI().customQuery(\n      {\n        aiOptions,\n        messages,\n      },\n      {\n        ...(oAuth2AccessToken && {\n          headers: {\n            Authorization: `Bearer ${oAuth2AccessToken}`,\n          },\n        }),\n      }\n    );\n\n    if (!response.data) {\n      throw new Error('No response from AI API');\n    }\n\n    const { fileContent, tokenUsed } = response.data;\n\n    const newContent = fileContent\n      .replaceAll('///chunksStart///', '')\n      .replaceAll('///chunkStart///', '')\n      .replaceAll('///chunksEnd///', '')\n      .replaceAll('///chunkEnd///', '');\n\n    lastResult = {\n      fileContent: newContent,\n      tokenUsed,\n    };\n  })();\n\n  return lastResult!;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAwD;AACxD,oBAA6B;AAWtB,MAAM,iBAAiB,OAC5B,UACA,WACA,sBACkC;AAClC,MAAI;AAEJ,YAAM,4BAAa,YAAY;AAC7B,UAAM,WAAW,UAAM,qBAAS,EAAE;AAAA,MAChC;AAAA,QACE;AAAA,QACA;AAAA,MACF;AAAA,MACA;AAAA,QACE,GAAI,qBAAqB;AAAA,UACvB,SAAS;AAAA,YACP,eAAe,UAAU,iBAAiB;AAAA,UAC5C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,QAAI,CAAC,SAAS,MAAM;AAClB,YAAM,IAAI,MAAM,yBAAyB;AAAA,IAC3C;AAEA,UAAM,EAAE,aAAa,UAAU,IAAI,SAAS;AAE5C,UAAM,aAAa,YAChB,WAAW,qBAAqB,EAAE,EAClC,WAAW,oBAAoB,EAAE,EACjC,WAAW,mBAAmB,EAAE,EAChC,WAAW,kBAAkB,EAAE;AAElC,iBAAa;AAAA,MACX,aAAa;AAAA,MACb;AAAA,IACF;AAAA,EACF,CAAC,EAAE;AAEH,SAAO;AACT;","names":[]}

package/dist/cjs/utils/fixChunkStartEndChars.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fixChunkStartEndChars_exports = {};
+__export(fixChunkStartEndChars_exports, {
+  fixChunkStartEndChars: () => fixChunkStartEndChars
+});
+module.exports = __toCommonJS(fixChunkStartEndChars_exports);
+const CHAR_TO_CHECK_FORMATTING = ["```", "\n\n", "\n", "---", "{{", "}}"];
+const escapeForRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\n/g, "\\n");
+const FORMATTING_REGEX_SOURCE = `(?:${CHAR_TO_CHECK_FORMATTING.map(escapeForRegExp).join("|")})+`;
+const LEADING_FORMATTING_REGEX = new RegExp(`^${FORMATTING_REGEX_SOURCE}`);
+const TRAILING_FORMATTING_REGEX = new RegExp(`${FORMATTING_REGEX_SOURCE}$`);
+const fixChunkStartEndChars = (reviewedChunkResult, baseChunkContext) => {
+  let result = reviewedChunkResult;
+  const baseLeading = baseChunkContext.match(LEADING_FORMATTING_REGEX)?.[0] ?? "";
+  const baseTrailing = baseChunkContext.match(TRAILING_FORMATTING_REGEX)?.[0] ?? "";
+  const resultLeading = result.match(LEADING_FORMATTING_REGEX)?.[0] ?? "";
+  const resultTrailing = result.match(TRAILING_FORMATTING_REGEX)?.[0] ?? "";
+  if (baseLeading !== resultLeading) {
+    result = baseLeading + result.slice(resultLeading.length);
+  }
+  if (baseTrailing !== resultTrailing) {
+    result = result.slice(0, result.length - resultTrailing.length) + baseTrailing;
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fixChunkStartEndChars
+});
+//# sourceMappingURL=fixChunkStartEndChars.cjs.map

package/dist/cjs/utils/fixChunkStartEndChars.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fixChunkStartEndChars.ts"],"sourcesContent":["const CHAR_TO_CHECK_FORMATTING = ['```', '\\n\\n', '\\n', '---', '{{', '}}'];\n\n// Escape a string for use in RegExp\nconst escapeForRegExp = (str: string) =>\n  str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&').replace(/\\n/g, '\\\\n');\n\n// Build once the regex that matches any combination of the formatting chars appearing\n// sequentially at the beginning or at the end of a string.\nconst FORMATTING_REGEX_SOURCE = `(?:${CHAR_TO_CHECK_FORMATTING.map(escapeForRegExp).join('|')})+`;\nconst LEADING_FORMATTING_REGEX = new RegExp(`^${FORMATTING_REGEX_SOURCE}`);\nconst TRAILING_FORMATTING_REGEX = new RegExp(`${FORMATTING_REGEX_SOURCE}$`);\n\nexport const fixChunkStartEndChars = (\n  reviewedChunkResult: string,\n  baseChunkContext: string\n) => {\n  let result = reviewedChunkResult;\n\n  const baseLeading =\n    baseChunkContext.match(LEADING_FORMATTING_REGEX)?.[0] ?? '';\n  const baseTrailing =\n    baseChunkContext.match(TRAILING_FORMATTING_REGEX)?.[0] ?? '';\n\n  const resultLeading = result.match(LEADING_FORMATTING_REGEX)?.[0] ?? '';\n  const resultTrailing = result.match(TRAILING_FORMATTING_REGEX)?.[0] ?? '';\n\n  // Fix leading formatting\n  if (baseLeading !== resultLeading) {\n    // Remove current leading formatting found in result and prepend the correct one\n    result = baseLeading + result.slice(resultLeading.length);\n  }\n\n  // Fix trailing formatting\n  if (baseTrailing !== resultTrailing) {\n    // Remove current trailing formatting found in result and append the correct one\n    result =\n      result.slice(0, result.length - resultTrailing.length) + baseTrailing;\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAAM,2BAA2B,CAAC,OAAO,QAAQ,MAAM,OAAO,MAAM,IAAI;AAGxE,MAAM,kBAAkB,CAAC,QACvB,IAAI,QAAQ,uBAAuB,MAAM,EAAE,QAAQ,OAAO,KAAK;AAIjE,MAAM,0BAA0B,MAAM,yBAAyB,IAAI,eAAe,EAAE,KAAK,GAAG,CAAC;AAC7F,MAAM,2BAA2B,IAAI,OAAO,IAAI,uBAAuB,EAAE;AACzE,MAAM,4BAA4B,IAAI,OAAO,GAAG,uBAAuB,GAAG;AAEnE,MAAM,wBAAwB,CACnC,qBACA,qBACG;AACH,MAAI,SAAS;AAEb,QAAM,cACJ,iBAAiB,MAAM,wBAAwB,IAAI,CAAC,KAAK;AAC3D,QAAM,eACJ,iBAAiB,MAAM,yBAAyB,IAAI,CAAC,KAAK;AAE5D,QAAM,gBAAgB,OAAO,MAAM,wBAAwB,IAAI,CAAC,KAAK;AACrE,QAAM,iBAAiB,OAAO,MAAM,yBAAyB,IAAI,CAAC,KAAK;AAGvE,MAAI,gBAAgB,eAAe;AAEjC,aAAS,cAAc,OAAO,MAAM,cAAc,MAAM;AAAA,EAC1D;AAGA,MAAI,iBAAiB,gBAAgB;AAEnC,aACE,OAAO,MAAM,GAAG,OAAO,SAAS,eAAe,MAAM,IAAI;AAAA,EAC7D;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/utils/fixChunkStartEndChars.test.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_fixChunkStartEndChars = require('./fixChunkStartEndChars.cjs');
+const visible = (str) => str.replace(/\n/g, "\\n");
+(0, import_vitest.describe)("fixChunkStartEndChars", () => {
+  (0, import_vitest.it)("should add the missing starting character when the base chunk starts with it", () => {
+    const base = "\nHello world";
+    const reviewed = "Hello world";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(visible(fixed)).toEqual(visible(base));
+  });
+  (0, import_vitest.it)("should add the missing ending character when the base chunk ends with it", () => {
+    const base = 'console.log("hi")```';
+    const reviewed = 'console.log("hi")';
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should remove the extra starting character when the base chunk does not start with it", () => {
+    const base = "Hello world";
+    const reviewed = "\nHello world";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(visible(fixed)).toEqual(visible(base));
+  });
+  (0, import_vitest.it)("should remove the extra ending character when the base chunk does not end with it", () => {
+    const base = "Hello world";
+    const reviewed = "Hello world---";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should return the reviewed chunk untouched when already matching the base structure", () => {
+    const base = "Plain text without special markers";
+    const reviewed = "Plain text without special markers";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should not remove ```` when the base chunk starts with it", () => {
+    const base = "```test";
+    const reviewed = "```test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should add ```` when the base chunk ends with it", () => {
+    const base = "```test";
+    const reviewed = "test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should remove ```` when the base chunk starts with it", () => {
+    const base = "test";
+    const reviewed = "```test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should not remove ```` when the base chunk finishes with it", () => {
+    const base = "test```";
+    const reviewed = "test```";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should add ```` when the base chunk finishes with it", () => {
+    const base = "test```";
+    const reviewed = "test";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should remove ```` when the base chunk finishes with it", () => {
+    const base = "test";
+    const reviewed = "test```";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(reviewed, base);
+    (0, import_vitest.expect)(fixed).toEqual(base);
+  });
+  (0, import_vitest.it)("should add the missing char is a char list that matching char list", () => {
+    const baseChunk = "```\n\n### 2. **Check if the command is registered**\n";
+    const aiGeneratedResult = "\n\n### 2. **V\xE9rifiez si la commande est enregistr\xE9e**\n";
+    const fixedResultError = "```### 2. **V\xE9rifiez si la commande est enregistr\xE9e**\n";
+    const fixedResultSuccess = "```\n\n### 2. **V\xE9rifiez si la commande est enregistr\xE9e**\n";
+    const fixed = (0, import_fixChunkStartEndChars.fixChunkStartEndChars)(aiGeneratedResult, baseChunk);
+    (0, import_vitest.expect)(fixed).toMatch(/^```\n\n### 2\./);
+  });
+});
+//# sourceMappingURL=fixChunkStartEndChars.test.cjs.map

package/dist/cjs/utils/fixChunkStartEndChars.test.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fixChunkStartEndChars.test.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest';\nimport { fixChunkStartEndChars } from './fixChunkStartEndChars';\n\n// Helper to visualise new line at the beginning/end of a string when debugging\nconst visible = (str: string) => str.replace(/\\n/g, '\\\\n');\n\ndescribe('fixChunkStartEndChars', () => {\n  it('should add the missing starting character when the base chunk starts with it', () => {\n    const base = '\\nHello world';\n    const reviewed = 'Hello world';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(visible(fixed)).toEqual(visible(base));\n  });\n\n  it('should add the missing ending character when the base chunk ends with it', () => {\n    const base = 'console.log(\"hi\")```';\n    const reviewed = 'console.log(\"hi\")';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should remove the extra starting character when the base chunk does not start with it', () => {\n    const base = 'Hello world';\n    const reviewed = '\\nHello world';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(visible(fixed)).toEqual(visible(base));\n  });\n\n  it('should remove the extra ending character when the base chunk does not end with it', () => {\n    const base = 'Hello world';\n    const reviewed = 'Hello world---';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should return the reviewed chunk untouched when already matching the base structure', () => {\n    const base = 'Plain text without special markers';\n    const reviewed = 'Plain text without special markers';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should not remove ```` when the base chunk starts with it', () => {\n    const base = '```test';\n    const reviewed = '```test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should add ```` when the base chunk ends with it', () => {\n    const base = '```test';\n    const reviewed = 'test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should remove ```` when the base chunk starts with it', () => {\n    const base = 'test';\n    const reviewed = '```test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should not remove ```` when the base chunk finishes with it', () => {\n    const base = 'test```';\n    const reviewed = 'test```';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should add ```` when the base chunk finishes with it', () => {\n    const base = 'test```';\n    const reviewed = 'test';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should remove ```` when the base chunk finishes with it', () => {\n    const base = 'test';\n    const reviewed = 'test```';\n\n    const fixed = fixChunkStartEndChars(reviewed, base);\n    expect(fixed).toEqual(base);\n  });\n\n  it('should add the missing char is a char list that matching char list', () => {\n    // Here the base chunk as entry for the AI\n    const baseChunk =\n      '```\\n' + '\\n' + '### 2. **Check if the command is registered**\\n';\n\n    // But the translation AI returned a content that is wrong, because the firsts chars are missing\n    const aiGeneratedResult =\n      '\\n' + '\\n' + '### 2. **Vérifiez si la commande est enregistrée**\\n';\n\n    // The current result is this one, but it's wrong because the \\n are missing\n    const fixedResultError =\n      '```### 2. **Vérifiez si la commande est enregistrée**\\n';\n\n    // The correct result should be this one, with the \\n at the beginning\n    const fixedResultSuccess =\n      '```\\n' + '\\n' + '### 2. **Vérifiez si la commande est enregistrée**\\n';\n\n    const fixed = fixChunkStartEndChars(aiGeneratedResult, baseChunk);\n\n    // Check if it start by '```\\n' + '\\n' + '### 2.'\n    expect(fixed).toMatch(/^```\\n\\n### 2\\./);\n  });\n});\n"],"mappings":";AAAA,oBAAqC;AACrC,mCAAsC;AAGtC,MAAM,UAAU,CAAC,QAAgB,IAAI,QAAQ,OAAO,KAAK;AAAA,IAEzD,wBAAS,yBAAyB,MAAM;AACtC,wBAAG,gFAAgF,MAAM;AACvF,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,QAAQ,KAAK,CAAC,EAAE,QAAQ,QAAQ,IAAI,CAAC;AAAA,EAC9C,CAAC;AAED,wBAAG,4EAA4E,MAAM;AACnF,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,yFAAyF,MAAM;AAChG,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,QAAQ,KAAK,CAAC,EAAE,QAAQ,QAAQ,IAAI,CAAC;AAAA,EAC9C,CAAC;AAED,wBAAG,qFAAqF,MAAM;AAC5F,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,uFAAuF,MAAM;AAC9F,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,6DAA6D,MAAM;AACpE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,oDAAoD,MAAM;AAC3D,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,yDAAyD,MAAM;AAChE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,+DAA+D,MAAM;AACtE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,wDAAwD,MAAM;AAC/D,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,2DAA2D,MAAM;AAClE,UAAM,OAAO;AACb,UAAM,WAAW;AAEjB,UAAM,YAAQ,oDAAsB,UAAU,IAAI;AAClD,8BAAO,KAAK,EAAE,QAAQ,IAAI;AAAA,EAC5B,CAAC;AAED,wBAAG,sEAAsE,MAAM;AAE7E,UAAM,YACJ;AAGF,UAAM,oBACJ;AAGF,UAAM,mBACJ;AAGF,UAAM,qBACJ;AAEF,UAAM,YAAQ,oDAAsB,mBAAmB,SAAS;AAGhE,8BAAO,KAAK,EAAE,QAAQ,iBAAiB;AAAA,EACzC,CAAC;AACH,CAAC;","names":[]}

package/dist/cjs/utils/formatTimeDiff.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var formatTimeDiff_exports = {};
+__export(formatTimeDiff_exports, {
+  formatTimeDiff: () => formatTimeDiff
+});
+module.exports = __toCommonJS(formatTimeDiff_exports);
+const formatTimeDiff = (realtiveTime) => {
+  const diff = realtiveTime.getTime();
+  const MS_IN_SECOND = 1e3;
+  const MS_IN_MINUTE = 60 * MS_IN_SECOND;
+  const MS_IN_HOUR = 60 * MS_IN_MINUTE;
+  const MS_IN_DAY = 24 * MS_IN_HOUR;
+  const days = Math.floor(diff / MS_IN_DAY);
+  const hours = Math.floor(diff % MS_IN_DAY / MS_IN_HOUR);
+  const minutes = Math.floor(diff % MS_IN_HOUR / MS_IN_MINUTE);
+  const seconds = Math.floor(diff % MS_IN_MINUTE / MS_IN_SECOND);
+  if (days > 0) {
+    return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  return `${minutes}m ${seconds}s`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatTimeDiff
+});
+//# sourceMappingURL=formatTimeDiff.cjs.map

package/dist/cjs/utils/formatTimeDiff.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/formatTimeDiff.ts"],"sourcesContent":["export const formatTimeDiff = (realtiveTime: Date): string => {\n  const diff = realtiveTime.getTime();\n\n  const MS_IN_SECOND = 1000;\n  const MS_IN_MINUTE = 60 * MS_IN_SECOND;\n  const MS_IN_HOUR = 60 * MS_IN_MINUTE;\n  const MS_IN_DAY = 24 * MS_IN_HOUR;\n\n  const days = Math.floor(diff / MS_IN_DAY);\n  const hours = Math.floor((diff % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((diff % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = Math.floor((diff % MS_IN_MINUTE) / MS_IN_SECOND);\n\n  if (days > 0) {\n    return `${days}d ${hours}h ${minutes}m ${seconds}s`;\n  }\n  if (hours > 0) {\n    return `${hours}h ${minutes}m ${seconds}s`;\n  }\n\n  return `${minutes}m ${seconds}s`;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,iBAAiB,CAAC,iBAA+B;AAC5D,QAAM,OAAO,aAAa,QAAQ;AAElC,QAAM,eAAe;AACrB,QAAM,eAAe,KAAK;AAC1B,QAAM,aAAa,KAAK;AACxB,QAAM,YAAY,KAAK;AAEvB,QAAM,OAAO,KAAK,MAAM,OAAO,SAAS;AACxC,QAAM,QAAQ,KAAK,MAAO,OAAO,YAAa,UAAU;AACxD,QAAM,UAAU,KAAK,MAAO,OAAO,aAAc,YAAY;AAC7D,QAAM,UAAU,KAAK,MAAO,OAAO,eAAgB,YAAY;AAE/D,MAAI,OAAO,GAAG;AACZ,WAAO,GAAG,IAAI,KAAK,KAAK,KAAK,OAAO,KAAK,OAAO;AAAA,EAClD;AACA,MAAI,QAAQ,GAAG;AACb,WAAO,GAAG,KAAK,KAAK,OAAO,KAAK,OAAO;AAAA,EACzC;AAEA,SAAO,GAAG,OAAO,KAAK,OAAO;AAC/B;","names":[]}

package/dist/cjs/utils/formatTimeDiff.test.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_formatTimeDiff = require('./formatTimeDiff.cjs');
+(0, import_vitest.describe)("formatTimeDiff", () => {
+  const fixedNow = /* @__PURE__ */ new Date("2025-01-01T00:00:00Z");
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+    import_vitest.vi.setSystemTime(fixedNow);
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.useRealTimers();
+  });
+  (0, import_vitest.it)("formats differences containing days", () => {
+    const past = new Date(
+      2 * 24 * 60 * 60 * 1e3 + // 2 days
+      3 * 60 * 60 * 1e3 + // 3 hours
+      4 * 60 * 1e3 + // 4 minutes
+      5 * 1e3
+      // 5 seconds
+    );
+    (0, import_vitest.expect)((0, import_formatTimeDiff.formatTimeDiff)(past)).toBe("2d 3h 4m 5s");
+  });
+  (0, import_vitest.it)("formats differences containing hours but no days", () => {
+    const past = new Date(3 * 60 * 60 * 1e3 + 15 * 60 * 1e3 + 20 * 1e3);
+    (0, import_vitest.expect)((0, import_formatTimeDiff.formatTimeDiff)(past)).toBe("3h 15m 20s");
+  });
+  (0, import_vitest.it)("formats differences containing only minutes and seconds", () => {
+    const past = new Date(7 * 60 * 1e3 + 45 * 1e3);
+    (0, import_vitest.expect)((0, import_formatTimeDiff.formatTimeDiff)(past)).toBe("7m 45s");
+  });
+});
+//# sourceMappingURL=formatTimeDiff.test.cjs.map