dsh-offwork 1.1.1 → 1.1.2

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/hydration-store.js

@@ -1,8 +1,22 @@
-import { defaultHydration, validateHydration } from './hydration.js';
+import { defaultHydration, validateHydration, migrateHydration } from './hydration.js';
 
 // A single IndexedDB read/write transaction is the cross-tab mutex. Neither
 // notification delivery nor localStorage read-back is used as an atomic lock.
-export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydration.v1') {
+export function createHydrationStore(
+  indexedDB,
+  name = 'dsh.offwork-clock.hydration.v1',
+  now = () => Date.now(),
+) {
+  return createStateStore(indexedDB, name, defaultHydration, validateHydration, {
+    version: 2,
+    storeName: 'wall-clock',
+    legacyStore: 'state',
+    migrate: (value) => migrateHydration(value, now()),
+  });
+}
+
+export function createStateStore(indexedDB, name, initial, validate, options = {}) {
+  const storeName = options.storeName || 'state';
   let database = null;
   let opening = null;
   let closed = false;
@@ -20,8 +34,11 @@ export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydrat
         reject(new Error('Hydration storage unavailable'));
         return;
       }
-      const request = indexedDB.open(name, 1);
-      request.onupgradeneeded = () => request.result.createObjectStore('state');
+      const request = indexedDB.open(name, options.version || 1);
+      request.onupgradeneeded = () => {
+        if (!request.result.objectStoreNames.contains(storeName))
+          request.result.createObjectStore(storeName);
+      };
       request.onerror = () => fail(request.error ?? new Error('Hydration storage unavailable'));
       request.onblocked = () => fail(new Error('Hydration storage blocked'));
       request.onsuccess = () => {
@@ -53,37 +70,59 @@ export function createHydrationStore(indexedDB, name = 'dsh.offwork-clock.hydrat
       const db = await open();
       if (closed) throw new Error('Hydration store closed');
       return new Promise((resolve, reject) => {
-        const transaction = db.transaction('state', 'readwrite');
-        const store = transaction.objectStore('state');
+        const hasLegacy =
+          !!options.legacyStore && db.objectStoreNames.contains(options.legacyStore);
+        const transaction = db.transaction(
+          hasLegacy ? [storeName, options.legacyStore] : storeName,
+          'readwrite',
+        );
+        const store = transaction.objectStore(storeName);
         const request = store.get('current');
         let output;
         let failure;
-        request.onsuccess = () => {
+        const apply = (stored, legacy, imported = false) => {
           try {
-            const current =
-              reset || request.result === undefined
-                ? defaultHydration()
-                : validateHydration(request.result);
-            const next = validateHydration(reducer(structuredClone(current)));
+            const current = reset
+              ? initial()
+              : stored !== undefined
+                ? validate(stored)
+                : imported
+                  ? validate(options.migrate(legacy))
+                  : initial();
+            const next = validate(reducer(structuredClone(current)));
             const changed = JSON.stringify(next) !== JSON.stringify(current);
-            const migrated =
-              request.result !== undefined && request.result.schema !== current.schema;
+            const migrated = imported || (stored !== undefined && stored.schema !== current.schema);
             if (reset || changed || migrated) {
               const previousRevision =
-                Number.isSafeInteger(request.result?.revision) && request.result.revision >= 0
-                  ? request.result.revision
+                Number.isSafeInteger(stored?.revision) && stored.revision >= 0
+                  ? stored.revision
                   : current.revision;
               next.revision = previousRevision + 1;
               if (!Number.isSafeInteger(next.revision))
                 throw new Error('Hydration revision exhausted');
               store.put(next, 'current');
             }
+            if (imported || (reset && hasLegacy)) store.put(true, 'legacy-imported');
             output = next;
           } catch (error) {
             failure = error;
             transaction.abort();
           }
         };
+        request.onsuccess = () => {
+          if (hasLegacy) {
+            const marker = store.get('legacy-imported');
+            marker.onsuccess = () => {
+              if (!reset && request.result === undefined && marker.result !== true) {
+                const legacy = transaction.objectStore(options.legacyStore).get('current');
+                legacy.onsuccess = () => apply(undefined, legacy.result, true);
+              } else {
+                if (marker.result !== true) store.put(true, 'legacy-imported');
+                apply(request.result);
+              }
+            };
+          } else apply(request.result);
+        };
         transaction.oncomplete = () => resolve(output);
         transaction.onabort = () =>
           reject(failure ?? transaction.error ?? new Error('Hydration transaction aborted'));