abacus-to-kimai-filler/lib/abacus-crawl.js

// Injected into the MyAbacus page (content script world, needs util.js + parse.js).
// Walks the "Gestion des temps" card day by day with the ‹ › buttons and stores results
// in browser.storage.local as it goes, so the popup can be closed meanwhile.
var AbacusCrawl = (() => {
  const SEL = {
    left: 'vaadin-button[movie-id="leftButton"]',
    right: 'vaadin-button[movie-id="rightButton"]',
    nav: '.proj-date-navigation',
    from: 'vaadin-text-field[id^="id_history_from_"]',
    to: 'vaadin-text-field[id^="id_history_to_"]',
    total: '#inOut .total-label .va-label-text',
  };
  const DATE_RE = /(\d{1,2})\.(\d{1,2})\.(\d{4})/;
  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

  const present = () => !!document.querySelector(SEL.right);

  function readDate() {
    const nav = document.querySelector(SEL.nav);
    if (!nav) return null;
    // sr-only "Date actuelle 02.10.2026", else the date picker input
    const m = DATE_RE.exec(nav.textContent) || DATE_RE.exec(nav.querySelector('input')?.value || '');
    return m ? `${m[3]}-${m[2].padStart(2, '0')}-${m[1].padStart(2, '0')}` : null;
  }

  // Native <input slot="input"> inside the vaadin-text-field (custom element props aren't visible from here)
  const fieldValue = (tf) => (tf.querySelector('input')?.value || '').trim();
  const suffix = (tf) => tf.id.replace(/^id_history_(from|to)_/, '');

  function readDay() {
    const tos = new Map([...document.querySelectorAll(SEL.to)].map((tf) => [suffix(tf), fieldValue(tf)]));
    const intervals = [], open = [];
    for (const tf of document.querySelectorAll(SEL.from)) {
      const s = U.toMin(fieldValue(tf)), e = U.toMin(tos.get(suffix(tf)) || '');
      if (s == null) continue;
      if (e == null) open.push(U.fmtTime(s));
      else if (e > s) intervals.push({ start: s, end: e });
    }
    const totalText = document.querySelector(SEL.total)?.textContent.trim() || '';
    return { date: readDate(), intervals: AbacusParse.union(intervals), open, total: U.toMin(totalText) };
  }

  // Wait until the date changed and the card content stopped moving
  async function waitLoaded(prevDate, timeout = 15000) {
    const t0 = Date.now();
    while (readDate() === prevDate) {
      if (Date.now() - t0 > timeout) throw new Error(`MyAbacus did not move away from ${prevDate}`);
      await sleep(100);
    }
    let last = '', stable = 0;
    while (stable < 3 && Date.now() - t0 < timeout) {
      await sleep(150);
      const snap = JSON.stringify(readDay());
      stable = snap === last ? stable + 1 : 0;
      last = snap;
    }
  }

  async function step(dir) {
    const prev = readDate();
    document.querySelector(dir < 0 ? SEL.left : SEL.right).click();
    await waitLoaded(prev);
  }

  function toLines(days) {
    return days.map((d) => {
      const iv = d.intervals.map((i) => `${U.fmtTime(i.start)}-${U.fmtTime(i.end)}`).join(' ');
      const sum = AbacusParse.sumIntervals(d.intervals);
      const notes = [];
      if (d.open.length) notes.push(`clocked in at ${d.open.join(', ')} without leaving`);
      if (d.total != null && d.intervals.length && d.total !== sum) notes.push(`Abacus total says ${U.fmtDur(d.total)}`);
      const note = notes.length ? `  # ${notes.join('; ')}` : '';
      if (iv) return `${d.date} ${iv}${note}`;
      if (d.total) return `${d.date} ${U.fmtDur(d.total)}${note}`;
      return `# ${d.date} nothing${note}`;
    }).join('\n');
  }

  async function run(from, to) {
    if (window.__abacusCrawling) return { error: 'already running' };
    if (!present()) return { skipped: true }; // other frame
    window.__abacusCrawling = true;
    const progress = (p) => browser.storage.local.set({ crawl: { ...p, at: new Date().toISOString() } });
    const days = [];
    try {
      await browser.storage.local.remove('crawlStop');
      let cur = readDate();
      if (!cur) throw new Error('Cannot read the current date in the card');
      const maxSteps = 400;
      let n = 0;
      // Move to `from` (two one-way loops: never oscillates if a day can't be shown)
      for (const dir of [-1, 1]) {
        while (dir < 0 ? cur > from : cur < from) {
          if (++n > maxSteps) throw new Error('Too many steps');
          await progress({ status: 'running', message: `Navigating to ${from} (at ${cur})` });
          await step(dir);
          cur = readDate();
        }
      }
      // Read each day up to `to`
      for (;;) {
        const { crawlStop } = await browser.storage.local.get('crawlStop');
        if (crawlStop) throw new Error('Stopped');
        days.push(readDay());
        await progress({ status: 'running', message: `Read ${cur} (${days.length} day(s))` });
        if (cur >= to || ++n > maxSteps) break;
        await step(1);
        cur = readDate();
      }
      const text = toLines(days);
      const parsed = AbacusParse.fromText(text).days;
      await browser.storage.local.set({
        daysText: text,
        extractInfo: { at: new Date().toISOString(), url: location.href, count: parsed.length, raw: days.map((d) => JSON.stringify(d)) },
      });
      await progress({ status: 'done', message: `Done: ${parsed.length} worked day(s) between ${from} and ${to}` });
      return { days };
    } catch (e) {
      if (days.length) await browser.storage.local.set({ daysText: toLines(days) + `\n# stopped: ${e.message}` });
      await progress({ status: 'error', message: e.message });
      return { error: e.message };
    } finally {
      window.__abacusCrawling = false;
    }
  }

  return { run, readDay, readDate, present };
})();