dsh-offwork 1.1.1 → 1.2.2

package/companion-image.js

@@ -0,0 +1,59 @@
+// Browser-only image intake: rasterize before persistence so imported SVG/URLs
+// never execute and backups contain a bounded, self-contained PNG.
+export async function loadCompanionImage(file, scope = window) {
+  if (
+    !file ||
+    !['image/png', 'image/webp', 'image/jpeg'].includes(file.type) ||
+    file.size > 5 * 1024 * 1024
+  )
+    throw new Error('请选择5MB以内的PNG、WebP或JPEG / Choose a PNG, WebP or JPEG under 5MB');
+  const magic = new Uint8Array(await file.slice(0, 24).arrayBuffer());
+  const signature =
+    file.type === 'image/png'
+      ? magic.length >= 24 && [137, 80, 78, 71, 13, 10, 26, 10].every((v, i) => magic[i] === v)
+      : file.type === 'image/webp'
+        ? String.fromCharCode(...magic.slice(0, 4)) === 'RIFF' &&
+          String.fromCharCode(...magic.slice(8, 12)) === 'WEBP'
+        : magic[0] === 255 && magic[1] === 216 && magic[2] === 255;
+  if (!signature) throw new Error('图片内容与格式不符 / Image signature does not match its format');
+  if (file.type === 'image/png') {
+    const header = new DataView(magic.buffer);
+    if (header.getUint32(16) * header.getUint32(20) > 24e6)
+      throw new Error('图片尺寸过大 / Image dimensions too large');
+  }
+  const url = scope.URL.createObjectURL(file);
+  try {
+    const image = new scope.Image();
+    image.src = url;
+    await image.decode();
+    if (
+      !image.naturalWidth ||
+      !image.naturalHeight ||
+      image.naturalWidth * image.naturalHeight > 24e6
+    )
+      throw new Error('图片尺寸过大 / Image dimensions too large');
+    return image;
+  } finally {
+    scope.URL.revokeObjectURL(url);
+  }
+}
+export function cropCompanionImage(image, { zoom = 1, x = 50, y = 50 } = {}, doc = document) {
+  const canvas = doc.createElement('canvas');
+  canvas.width = 384;
+  canvas.height = 512;
+  const ctx = canvas.getContext('2d');
+  const base = Math.max(canvas.width / image.naturalWidth, canvas.height / image.naturalHeight);
+  const scale = base * Math.max(1, Math.min(3, zoom));
+  const width = image.naturalWidth * scale,
+    height = image.naturalHeight * scale;
+  ctx.drawImage(
+    image,
+    (-(width - canvas.width) * Math.max(0, Math.min(100, x))) / 100,
+    (-(height - canvas.height) * Math.max(0, Math.min(100, y))) / 100,
+    width,
+    height,
+  );
+  const data = canvas.toDataURL('image/png');
+  if (data.length > 1500000) throw new Error('图片过大，请缩小后重试 / Image is too large');
+  return data;
+}

package/companion-state.js

@@ -0,0 +1,424 @@
+import {
+  defaultCountdown,
+  validateCountdown,
+  countdownView,
+  transitionCountdown,
+} from './countdown.js';
+import { hydrationView, validateHydration } from './hydration.js';
+import { normalizeView } from './ui-utils.js';
+
+// Shared companion state. All updates run inside createStateStore transactions.
+export const COMPANION_DB = 'dsh.offwork-clock.companion.v1';
+export const COMPANION_THEMES = {
+  host: '',
+  lavender: '#7779bc',
+  ocean: '#397fbd',
+  rose: '#b96c89',
+  slate: '#65748b',
+};
+export function defaultCompanionState() {
+  return {
+    schema: 1,
+    revision: 0,
+    preferences: {
+      sound: false,
+      notifications: false,
+      quietUntil: 0,
+      wrapEnabled: false,
+      leadMinutes: 10,
+      deferTyping: true,
+      linkedSession: '',
+      theme: 'host',
+      cardScale: 1,
+      customEnabled: false,
+      image: null,
+    },
+    timers: [],
+    deliveries: {},
+    journal: {},
+    history: [],
+  };
+}
+function companionAssert(condition) {
+  if (!condition) throw new Error('Invalid companion data / 搭子数据格式无效');
+}
+const companionTime = (n) => Number.isSafeInteger(n) && n >= 0;
+const companionText = (s, max) => typeof s === 'string' && s.length <= max;
+export function validateCompanionState(value) {
+  companionAssert(value?.schema === 1 && companionTime(value.revision));
+  const p = value.preferences;
+  companionAssert(
+    p && Object.keys(p).every((k) => Object.hasOwn(defaultCompanionState().preferences, k)),
+  );
+  companionAssert(
+    p &&
+      ['sound', 'notifications', 'wrapEnabled', 'deferTyping', 'customEnabled'].every(
+        (k) => typeof p[k] === 'boolean',
+      ),
+  );
+  companionAssert(
+    companionTime(p.quietUntil) &&
+      Number.isInteger(p.leadMinutes) &&
+      p.leadMinutes >= 0 &&
+      p.leadMinutes <= 60,
+  );
+  companionAssert(companionText(p.linkedSession, 200) && Object.hasOwn(COMPANION_THEMES, p.theme));
+  companionAssert([0.9, 1, 1.1, 1.2].includes(p.cardScale));
+  companionAssert(
+    p.image === null ||
+      (typeof p.image === 'string' &&
+        p.image.length <= 1500000 &&
+        /^data:image\/png;base64,[A-Za-z0-9+/]+=*$/.test(p.image)),
+  );
+  companionAssert(Array.isArray(value.timers) && value.timers.length <= 8);
+  const ids = new Set();
+  for (const t of value.timers) {
+    companionAssert(
+      companionText(t.id, 80) &&
+        /^[a-zA-Z0-9_-]+$/.test(t.id) &&
+        !ids.has(t.id) &&
+        companionText(t.name, 40) &&
+        t.name.trim().length > 0,
+    );
+    ids.add(t.id);
+    validateCountdown(t.clock);
+  }
+  companionAssert(
+    value.deliveries &&
+      typeof value.deliveries === 'object' &&
+      !Array.isArray(value.deliveries) &&
+      Object.keys(value.deliveries).length <= 128,
+  );
+  for (const [id, d] of Object.entries(value.deliveries)) {
+    companionAssert(
+      companionText(id, 250) && !['__proto__', 'constructor', 'prototype'].includes(id),
+    );
+    companionAssert(
+      d &&
+        ['dueAt', 'createdAt', 'snoozeUntil', 'leaseUntil', 'notifiedAt'].every((k) =>
+          companionTime(d[k]),
+        ) &&
+        typeof d.dismissed === 'boolean' &&
+        companionText(d.owner, 100),
+    );
+  }
+  companionAssert(
+    value.journal &&
+      typeof value.journal === 'object' &&
+      !Array.isArray(value.journal) &&
+      Object.keys(value.journal).length <= 120,
+  );
+  for (const [date, j] of Object.entries(value.journal)) {
+    companionAssert(
+      /^\d{4}-\d{2}-\d{2}$/.test(date) &&
+        companionText(j.done, 500) &&
+        companionText(j.next, 500) &&
+        companionTime(j.endedAt) &&
+        companionTime(j.updatedAt),
+    );
+  }
+  companionAssert(Array.isArray(value.history) && value.history.length <= 1500);
+  for (const e of value.history)
+    companionAssert(
+      companionText(e.id, 250) &&
+        companionText(e.label, 80) &&
+        ['water', 'timer', 'wrap'].includes(e.type) &&
+        companionTime(e.at),
+    );
+  return structuredClone({
+    schema: 1,
+    revision: value.revision,
+    preferences: p,
+    timers: value.timers,
+    deliveries: value.deliveries,
+    journal: value.journal,
+    history: value.history,
+  });
+}
+export function companionEvents(state, input, now) {
+  const events = [];
+  if (input.smokingReady && countdownView(input.smoking, now).phase === 'due')
+    events.push({
+      id: 'smoking:' + input.smoking.deadline,
+      kind: 'smoking',
+      dueAt: input.smoking.deadline,
+      label: input.smokingLabel,
+    });
+  const waterClaim = input.water?.claim;
+  const waterOwnedElsewhere =
+    input.waterOwner &&
+    waterClaim?.owner !== input.waterOwner &&
+    waterClaim?.sequence === input.water?.sequence &&
+    waterClaim?.until > now &&
+    waterClaim.until <= now + 8000;
+  if (input.waterReady && !waterOwnedElsewhere && hydrationView(input.water, now).phase === 'due') {
+    const view = hydrationView(input.water, now);
+    events.push({
+      id: 'water:' + view.eventId,
+      kind: 'water',
+      eventId: view.eventId,
+      dueAt: input.water.dueAt,
+      label: input.waterLabel,
+    });
+  }
+  for (const timer of state.timers)
+    if (countdownView(timer.clock, now).phase === 'due')
+      events.push({
+        id: 'timer:' + timer.id + ':' + timer.clock.deadline,
+        kind: 'timer',
+        timerId: timer.id,
+        dueAt: timer.clock.deadline,
+        label: timer.name,
+      });
+  const shift = input.shift;
+  if (
+    state.preferences.wrapEnabled &&
+    shift?.isWorkday &&
+    now >= shift.shiftStart &&
+    !state.journal[shift.shiftDate]?.endedAt
+  ) {
+    const dueAt = shift.shiftEnd - state.preferences.leadMinutes * 60000;
+    if (now >= dueAt)
+      events.push({
+        id: 'wrap:' + shift.shiftDate + ':' + shift.shiftEnd,
+        kind: 'wrap',
+        date: shift.shiftDate,
+        dueAt,
+        label: input.wrapLabel,
+      });
+  }
+  return events.sort((a, b) => a.dueAt - b.dueAt);
+}
+export function companionPending(state, events, now) {
+  if (state.preferences.quietUntil > now) return [];
+  return events.filter((e) => {
+    const d = state.deliveries[e.id];
+    return d && !d.dismissed && d.snoozeUntil <= now;
+  });
+}
+export function reconcileCompanion(state, events, now) {
+  const next = validateCompanionState(state);
+  const active = new Set(events.map((e) => e.id));
+  for (const event of events)
+    if (!Object.hasOwn(next.deliveries, event.id))
+      next.deliveries[event.id] = {
+        dueAt: event.dueAt,
+        createdAt: now,
+        snoozeUntil: 0,
+        dismissed: false,
+        owner: '',
+        leaseUntil: 0,
+        notifiedAt: 0,
+      };
+  const records = Object.entries(next.deliveries).sort((a, b) => b[1].createdAt - a[1].createdAt);
+  next.deliveries = Object.fromEntries(
+    records
+      .filter(([id, d], i) => active.has(id) || (i < 100 && now - d.createdAt < 90 * 86400000))
+      .slice(0, 128),
+  );
+  next.history = next.history.filter((e) => now - e.at < 90 * 86400000).slice(-1500);
+  return next;
+}
+export function companionTransition(value, action, now) {
+  const state = validateCompanionState(value);
+  companionAssert(companionTime(now));
+  const record = () => {
+    const d = state.deliveries[action.id];
+    if (!d) throw new Error('Reminder changed / 提醒已变化');
+    return d;
+  };
+  switch (action.type) {
+    case 'preferences':
+      companionAssert(
+        action.patch && Object.keys(action.patch).every((k) => Object.hasOwn(state.preferences, k)),
+      );
+      Object.assign(state.preferences, action.patch);
+      break;
+    case 'dismiss': {
+      const d = record();
+      d.dismissed = true;
+      d.owner = '';
+      d.leaseUntil = 0;
+      break;
+    }
+    case 'snooze': {
+      const d = record();
+      d.snoozeUntil = now + 10 * 60000;
+      d.dismissed = false;
+      d.owner = '';
+      d.leaseUntil = 0;
+      d.notifiedAt = 0;
+      break;
+    }
+    case 'claim': {
+      const d = record();
+      if (
+        !d.dismissed &&
+        d.snoozeUntil <= now &&
+        state.preferences.quietUntil <= now &&
+        (d.owner === action.owner || d.leaseUntil <= now)
+      ) {
+        d.owner = action.owner;
+        d.leaseUntil = now + 8000;
+      }
+      break;
+    }
+    case 'notify': {
+      const d = record();
+      if (
+        !d.notifiedAt &&
+        !d.dismissed &&
+        d.snoozeUntil <= now &&
+        state.preferences.quietUntil <= now
+      )
+        d.notifiedAt = now;
+      break;
+    }
+    case 'release':
+      for (const d of Object.values(state.deliveries))
+        if (d.owner === action.owner) {
+          d.owner = '';
+          d.leaseUntil = 0;
+        }
+      break;
+    case 'add-timer': {
+      if (state.timers.length >= 8) throw new Error('最多保存8个计时 / Up to 8 timers');
+      if (state.timers.some((t) => t.id === action.id)) break;
+      state.timers.push({
+        id: action.id,
+        name: action.name.trim(),
+        clock: { ...defaultCountdown(), minutes: action.minutes },
+      });
+      break;
+    }
+    case 'timer': {
+      const timer = state.timers.find((t) => t.id === action.id);
+      if (!timer || timer.clock.revision !== action.revision)
+        throw new Error('Timer changed / 计时已在其他页面改变，请重试');
+      if (action.operation.type === 'delete') {
+        state.timers = state.timers.filter((t) => t !== timer);
+        break;
+      }
+      timer.clock = transitionCountdown(timer.clock, action.operation, now);
+      timer.clock.revision++;
+      break;
+    }
+    case 'journal': {
+      const previous = state.journal[action.date];
+      if ((previous?.updatedAt || 0) !== action.base)
+        throw new Error('Notes changed in another tab / 另一页面已修改收尾记录，请重新打开');
+      state.journal[action.date] = {
+        done: action.done,
+        next: action.next,
+        endedAt: action.end ? now : previous?.endedAt || 0,
+        updatedAt: Math.max(now, (previous?.updatedAt || 0) + 1),
+      };
+      state.journal = Object.fromEntries(
+        Object.entries(state.journal)
+          .sort(([a], [b]) => b.localeCompare(a))
+          .slice(0, 120),
+      );
+      if (action.end && !state.history.some((e) => e.id === 'wrap:' + action.date))
+        state.history.push({ id: 'wrap:' + action.date, type: 'wrap', at: now, label: 'Wrap-up' });
+      break;
+    }
+    case 'record':
+      if (!state.history.some((e) => e.id === action.event.id)) state.history.push(action.event);
+      state.history = state.history.slice(-1500);
+      break;
+    case 'restore': {
+      const restored = validateCompanionState(action.value);
+      if (
+        state.revision !== action.base &&
+        (!action.stamp || companionStateStamp(state) !== action.stamp)
+      )
+        throw new Error('Data changed; preview the backup again / 数据已变化，请重新预览备份');
+      restored.revision = state.revision;
+      restored.preferences.sound = false;
+      restored.preferences.notifications = false;
+      for (const d of Object.values(restored.deliveries)) {
+        d.owner = '';
+        d.leaseUntil = 0;
+      }
+      return restored;
+    }
+    default:
+      throw new Error('Unknown companion action');
+  }
+  return validateCompanionState(state);
+}
+export function companionDaySummary(state, date, timezone) {
+  const formatter = new Intl.DateTimeFormat('en-CA', {
+    timeZone: timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  });
+  const localDate = (at) => {
+    const p = Object.fromEntries(formatter.formatToParts(at).map((p) => [p.type, p.value]));
+    return `${p.year}-${p.month}-${p.day}`;
+  };
+  const events = state.history.filter((e) => localDate(e.at) === date);
+  return {
+    water: events.filter((e) => e.type === 'water').length,
+    timers: events.filter((e) => e.type === 'timer').length,
+  };
+}
+
+export function validateBrowserBackup(value) {
+  companionAssert(
+    value?.format === 'dsh-offwork-browser' &&
+      value.version === 1 &&
+      companionTime(value.createdAt),
+  );
+  return {
+    format: value.format,
+    version: 1,
+    createdAt: value.createdAt,
+    companion: validateCompanionState(value.companion),
+    water: validateHydration(value.water),
+    smoking: validateCountdown(value.smoking),
+    view: normalizeView(value.view),
+  };
+}
+// Ignore transient leases and revisions; user-visible changes invalidate a restore preview.
+export function companionStateStamp(c) {
+  return JSON.stringify({
+    preferences: c.preferences,
+    timers: c.timers,
+    journal: c.journal,
+    history: c.history,
+    choices: Object.entries(c.deliveries)
+      .filter(([, d]) => d.dismissed || d.snoozeUntil)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([id, d]) => [id, d.dismissed, d.snoozeUntil]),
+  });
+}
+export function companionWaterStamp(w) {
+  const { claim, revision, ...value } = w;
+  return JSON.stringify(value);
+}
+export function companionBackupStamp(value) {
+  const { revision: smokeRevision, ...smoking } = value.smoking;
+  return JSON.stringify({
+    companion: companionStateStamp(value.companion),
+    water: companionWaterStamp(value.water),
+    smoking,
+    view: value.view,
+  });
+}
+export function createCompanionRecoveryStore(indexedDB, createStore) {
+  return createStore(
+    indexedDB,
+    'dsh.offwork-clock.restore.v1',
+    () => ({ schema: 1, revision: 0, bundle: null }),
+    (value) => {
+      companionAssert(value?.schema === 1 && companionTime(value.revision));
+      return {
+        schema: 1,
+        revision: value.revision,
+        bundle: value.bundle === null ? null : validateBrowserBackup(value.bundle),
+      };
+    },
+  );
+}

package/companion.js

@@ -14,9 +14,7 @@ export function companionPresentation({
     return { visible: false, pose: 'calm', message: null, announce: false, animate: false };
   let pose = 'calm';
   let message = 'companionWorking';
-  const quiet =
-    ['quiet', 'paused'].includes(phase) && !['before', 'done', 'rest'].includes(workStatus);
-  const resting = ['lunch', 'rest', 'done', 'before'].includes(workStatus);
+  const quiet = ['quiet', 'paused'].includes(phase);
   if (!ready) {
     pose = 'rest';
     message = 'companionLoading';
@@ -26,6 +24,9 @@ export function companionPresentation({
   } else if (quiet) {
     pose = 'quiet';
     message = phase === 'quiet' ? 'companionQuiet' : 'companionPaused';
+  } else if (phase === 'due' && ownsPrompt) {
+    pose = 'drink';
+    message = null;
   } else if (workStatus === 'lunch') {
     pose = 'rest';
     message = 'companionBreak';
@@ -38,17 +39,13 @@ export function companionPresentation({
   } else if (workStatus === 'before') {
     pose = 'rest';
     message = 'companionBefore';
-  } else if (phase === 'due' && ownsPrompt) {
-    // The existing leased reminder is the only source of the due message.
-    pose = 'drink';
-    message = null;
   }
   let announce = false;
   let animate = false;
   if (ready && !failed && !(phase === 'due' && ownsPrompt) && feedback) {
     message = feedback.key;
     announce = true;
-    if (feedback.kind === 'drink' && !quiet && !resting) {
+    if (feedback.kind === 'drink' && !quiet) {
       pose = 'happy';
       animate = motion && pageVisible;
     }
@@ -132,7 +129,7 @@ export const COMPANION_MESSAGES = {
     companionPreferences: '立即生效，保存在本浏览器。隐藏角色后仍可使用计时和喝水操作。',
     companionWorking: '你忙你的，我陪你记着时间。',
     companionQuiet: '好，先安静陪着你。',
-    companionPaused: '本班先不提醒，需要时再叫我。',
+    companionPaused: '提醒先暂停，需要时再叫我。',
     companionBreak: '休息一下，回来再继续。',
     companionBefore: '还没开工，先慢慢准备。',
     companionDone: '这一班结束啦，辛苦了。',

package/countdown.js

@@ -0,0 +1,83 @@
+// A user-started wall-clock countdown. No hydration or salary state is involved.
+export const SMOKING_TIMER_DB = 'dsh.offwork-clock.smoking.v1';
+export const COUNTDOWN_INTERVALS = [
+  1, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 240, 480, 720, 1440,
+];
+export function defaultCountdown() {
+  return { schema: 1, revision: 0, minutes: 60, status: 'idle', deadline: 0, remaining: 0 };
+}
+export function validateCountdown(value) {
+  const integer = (n) => Number.isSafeInteger(n) && n >= 0;
+  if (
+    !value ||
+    value.schema !== 1 ||
+    !integer(value.revision) ||
+    !Number.isInteger(value.minutes) ||
+    value.minutes < 1 ||
+    value.minutes > 1440 ||
+    !['idle', 'running', 'paused'].includes(value.status) ||
+    !integer(value.deadline) ||
+    !integer(value.remaining) ||
+    value.remaining > 86400000 ||
+    (value.status === 'running'
+      ? value.deadline === 0 || value.remaining !== 0
+      : value.deadline !== 0) ||
+    (value.status === 'idle' && value.remaining !== 0) ||
+    (value.status === 'paused' && value.remaining === 0)
+  )
+    throw new Error('Invalid countdown state');
+  return {
+    schema: 1,
+    revision: value.revision,
+    minutes: value.minutes,
+    status: value.status,
+    deadline: value.deadline,
+    remaining: value.remaining,
+  };
+}
+export function countdownView(value, now) {
+  const remaining =
+    value.status === 'running' ? Math.max(0, value.deadline - now) : value.remaining;
+  return { remaining, phase: value.status === 'running' && remaining === 0 ? 'due' : value.status };
+}
+export function transitionCountdown(value, action, now) {
+  const state = validateCountdown(value);
+  if (!Number.isSafeInteger(now) || now < 0) throw new Error('Invalid countdown time');
+  const current = countdownView(state, now);
+  switch (action.type) {
+    case 'interval':
+      state.minutes = action.minutes;
+      break;
+    case 'start':
+      if (current.phase !== 'idle' && current.phase !== 'due') return state;
+      state.status = 'running';
+      state.deadline = now + state.minutes * 60000;
+      state.remaining = 0;
+      break;
+    case 'restart':
+      state.status = 'running';
+      state.deadline = now + state.minutes * 60000;
+      state.remaining = 0;
+      break;
+    case 'pause':
+      if (current.phase !== 'running') return state;
+      state.status = 'paused';
+      state.remaining = Math.min(86400000, current.remaining);
+      state.deadline = 0;
+      break;
+    case 'resume':
+      if (current.phase !== 'paused') return state;
+      state.status = 'running';
+      state.deadline = now + state.remaining;
+      state.remaining = 0;
+      break;
+    case 'stop':
+      state.status = 'idle';
+      state.deadline = 0;
+      state.remaining = 0;
+      break;
+    default:
+      throw new Error('Unknown countdown action');
+  }
+  return validateCountdown(state);
+}

package/docs/RELEASE-1.2.2.md

@@ -0,0 +1,20 @@
+# 1.2.2：页面收拢与信息层级
+
+本地候选版，尚未发布到 GitHub/npm。
+
+## 主要调整
+
+- 下班卡片只保留计时、班次详情、收尾入口和收入明细。刷新与作息设置不再作为并列文字按钮，设置入口放到卡片右上角。
+- 卡片标题会跟随状态显示“上班倒计时 / 下班倒计时 / 本班已完成 / 今天休息”。
+- 外观页的角色选择在主区域，大小、透明度和动作收进“显示与动作”；预览高度缩短，主题、卡片尺寸和自定义人物统一通过底部“应用”保存。
+- 设置页按“入口 / 提醒 / 高级”分层：作息薪资、喝水间隔、备份恢复是清晰的行入口；提示音、通知、免打扰和下班提醒集中展示；测试提示与代理权限折叠在高级设置。
+- “全部免打扰30分钟”使用明确的按钮样式；链接箭头不再混入按钮辅助名称。
+- 人物卡片不再长期显示“喝了一杯”。只有喝水提醒到期时才显示快捷记录；平时从喝水卡片操作。
+- 自定义计时运行中仍显示在人物脚下，点击回到计时卡片。
+
+## 验证
+
+- 187项Node测试通过，格式、生成物、语法和打包检查通过。
+- 隔离Harness Chromium回归：计时/喝水/收尾/外观/备份、未保存保护、到点稍后、非宠物模式、快捷入口、320/390/640视口和触屏深色主题。
+- 实际 xxy 环境加载 `data-version=1.2.2`，设置接口 HTTP 200，页面无运行错误。
+- 旧薪资、喝水、抽烟、计时和外观数据沿用；不清理站点数据。