@shaxpir/duiduidui-models 1.7.2 → 1.7.4

package/dist/models/Metric.d.ts

@@ -34,7 +34,7 @@ export declare class Metric extends Content {
     get maxDate(): CompactDate;
     get length(): number;
     get(index: number): MetricEntry;
-    sumBetween(minDate: CompactDate, maxDate: CompactDate): number;
+    sumBetween(minDate?: CompactDate | null, maxDate?: CompactDate | null): number;
     forDate(date: CompactDate): number;
     nonZeroDayCount(): number;
     setDateAmount(date: CompactDate, amount: number): void;

package/dist/models/Metric.js

@@ -97,8 +97,16 @@ class Metric extends Content_1.Content {
     }
     sumBetween(minDate, maxDate) {
         this.checkDisposed("Metric.sumBetween");
+        // Use payload min/max dates as defaults for null parameters
+        const effectiveMinDate = minDate || this.payload.min_date;
+        const effectiveMaxDate = maxDate || this.payload.max_date;
+        // If we still don't have dates (empty metric), return 0
+        if (!effectiveMinDate || !effectiveMaxDate) {
+            return 0;
+        }
+        // Sum between the effective dates
         let sum = 0;
-        const dates = shaxpir_common_1.Time.datesBetween(minDate, maxDate);
+        const dates = shaxpir_common_1.Time.datesBetween(effectiveMinDate, effectiveMaxDate);
         for (let i = 0, len = dates.length; i < len; i++) {
             const date = dates[i];
             sum += this.forDate(date);

package/dist/models/Progress.d.ts

@@ -30,6 +30,7 @@ export interface ProgressPayload {
     skill_level: UncertainValue;
     cognitive_load: number;
     streaks?: StreakData;
+    total_review_count: number;
 }
 export interface ProgressBody extends ContentBody {
     meta: ContentMeta;
@@ -55,4 +56,6 @@ export declare class Progress extends Content {
     setCognitiveLoad(value: number): void;
     getStreaks(): StreakData | undefined;
     setStreaks(streaks: StreakData): void;
+    getTotalReviewCount(): number;
+    setTotalReviewCount(count: number): void;
 }

package/dist/models/Progress.js

@@ -31,7 +31,8 @@ class Progress extends Content_1.Content {
                         upper: 1000 // Could potentially be advanced
                     }
                 },
-                cognitive_load: 0
+                cognitive_load: 0,
+                total_review_count: 0 // Start with zero lifetime reviews
             }
         });
     }
@@ -134,5 +135,17 @@ class Progress extends Content_1.Content {
             batch.commit();
         }
     }
+    getTotalReviewCount() {
+        this.checkDisposed("Progress.getTotalReviewCount");
+        return this.payload.total_review_count;
+    }
+    setTotalReviewCount(count) {
+        this.checkDisposed("Progress.setTotalReviewCount");
+        if (this.payload.total_review_count !== count) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'total_review_count'], count);
+            batch.commit();
+        }
+    }
 }
 exports.Progress = Progress;

package/dist/models/Session.d.ts

@@ -23,7 +23,7 @@ export interface SessionConfig {
         auto_play_speech?: boolean;
     };
 }
-export interface SessionMetrics {
+export interface SessionStats {
     skill_level: UncertainValue;
     cognitive_load: number;
     theta_distribution: {
@@ -58,9 +58,9 @@ export interface SessionPayload {
     is_complete: boolean;
     app_version?: string;
     config?: SessionConfig;
-    metrics?: {
-        before?: SessionMetrics;
-        after?: SessionMetrics;
+    stats?: {
+        before?: SessionStats;
+        after?: SessionStats;
     };
 }
 export interface SessionBody extends ContentBody {
@@ -87,10 +87,10 @@ export declare class Session extends Content {
     setConfig(config: SessionConfig): void;
     get isComplete(): boolean;
     markComplete(): void;
-    get metricsBefore(): SessionMetrics | undefined;
-    setMetricsBefore(metrics: SessionMetrics): void;
-    get metricsAfter(): SessionMetrics | undefined;
-    setMetricsAfter(metrics: SessionMetrics): void;
+    get statsBefore(): SessionStats | undefined;
+    setStatsBefore(stats: SessionStats): void;
+    get statsAfter(): SessionStats | undefined;
+    setStatsAfter(stats: SessionStats): void;
     isActive(): boolean;
     get appVersion(): string | undefined;
     setAppVersion(version: string): void;

package/dist/models/Session.js

@@ -8,6 +8,8 @@ const Content_1 = require("./Content");
 const ContentKind_1 = require("./ContentKind");
 const Metric_1 = require("./Metric");
 const Operation_1 = require("./Operation");
+const Progress_1 = require("./Progress");
+const Streaks_1 = require("./Streaks");
 const Workspace_1 = require("./Workspace");
 class Session extends Content_1.Content {
     constructor(doc, shouldAcquire, shareSync) {
@@ -128,30 +130,30 @@ class Session extends Content_1.Content {
         batch.setPathValue(['payload', 'is_complete'], true);
         batch.commit();
     }
-    get metricsBefore() {
-        this.checkDisposed("Session.metricsBefore");
-        return this.payload.metrics?.before;
+    get statsBefore() {
+        this.checkDisposed("Session.statsBefore");
+        return this.payload.stats?.before;
     }
-    setMetricsBefore(metrics) {
-        this.checkDisposed("Session.setMetricsBefore");
+    setStatsBefore(stats) {
+        this.checkDisposed("Session.setStatsBefore");
         const batch = new Operation_1.BatchOperation(this);
-        if (!this.payload.metrics) {
-            batch.setPathValue(['payload', 'metrics'], {});
+        if (!this.payload.stats) {
+            batch.setPathValue(['payload', 'stats'], {});
         }
-        batch.setPathValue(['payload', 'metrics', 'before'], metrics);
+        batch.setPathValue(['payload', 'stats', 'before'], stats);
         batch.commit();
     }
-    get metricsAfter() {
-        this.checkDisposed("Session.metricsAfter");
-        return this.payload.metrics?.after;
+    get statsAfter() {
+        this.checkDisposed("Session.statsAfter");
+        return this.payload.stats?.after;
     }
-    setMetricsAfter(metrics) {
-        this.checkDisposed("Session.setMetricsAfter");
+    setStatsAfter(stats) {
+        this.checkDisposed("Session.setStatsAfter");
         const batch = new Operation_1.BatchOperation(this);
-        if (!this.payload.metrics) {
-            batch.setPathValue(['payload', 'metrics'], {});
+        if (!this.payload.stats) {
+            batch.setPathValue(['payload', 'stats'], {});
         }
-        batch.setPathValue(['payload', 'metrics', 'after'], metrics);
+        batch.setPathValue(['payload', 'stats', 'after'], stats);
         batch.commit();
     }
     isActive() {
@@ -201,7 +203,22 @@ class Session extends Content_1.Content {
         const reviewCountMetricId = Metric_1.Metric.makeMetricId(userId, Metric_1.MetricName.REVIEW_COUNT);
         const reviewCountMetric = await shareSync.acquire(ContentKind_1.ContentKind.METRIC, reviewCountMetricId);
         reviewCountMetric.setDateAmount(date, reviewCountOnDate);
+        // Calculate total review count using sumBetween with null arguments (sums all entries)
+        const totalReviewCount = reviewCountMetric.sumBetween(null, null);
         reviewCountMetric.release();
+        // Update total review count in Progress
+        const progressId = Progress_1.Progress.makeProgressId(userId);
+        const progress = await shareSync.acquire(ContentKind_1.ContentKind.PROGRESS, progressId);
+        progress.setTotalReviewCount(totalReviewCount);
+        // Calculate streaks based on metrics
+        const now = shaxpir_common_1.ClockService.getClock().now();
+        const today = shaxpir_common_1.Time.dateFrom(now.local_time);
+        // Use the Streaks class to calculate streak data
+        const streakData = Streaks_1.Streaks.calculateFromMetric(minutesStudyingMetric, today);
+        if (streakData) {
+            progress.setStreaks(streakData);
+        }
+        progress.release();
     }
 }
 exports.Session = Session;

package/dist/models/Streaks.d.ts

@@ -0,0 +1,14 @@
+import { CompactDate } from "@shaxpir/shaxpir-common";
+import { Metric } from './Metric';
+import { StreakData } from './Progress';
+export declare class Streaks {
+    /**
+     * Calculate streak data from a Metric containing activity dates.
+     * Returns daily, weekly, and monthly streak information.
+     *
+     * @param metric - The Metric model containing activity data
+     * @param today - The current date for streak calculation
+     * @returns StreakData object with streak information, or null if no activity
+     */
+    static calculateFromMetric(metric: Metric, today: CompactDate): StreakData | null;
+}

package/dist/models/Streaks.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Streaks = void 0;
+const shaxpir_common_1 = require("@shaxpir/shaxpir-common");
+class Streaks {
+    /**
+     * Calculate streak data from a Metric containing activity dates.
+     * Returns daily, weekly, and monthly streak information.
+     *
+     * @param metric - The Metric model containing activity data
+     * @param today - The current date for streak calculation
+     * @returns StreakData object with streak information, or null if no activity
+     */
+    static calculateFromMetric(metric, today) {
+        const minDate = metric.minDate;
+        const maxDate = metric.maxDate;
+        if (!minDate || !maxDate) {
+            return null;
+        }
+        // Get all dates between min and max using Metric's datesBetween
+        const allDates = shaxpir_common_1.Time.datesBetween(minDate, maxDate);
+        const activityDates = [];
+        // Collect dates with actual activity
+        for (const date of allDates) {
+            if (metric.forDate(date) > 0) {
+                activityDates.push(date);
+            }
+        }
+        if (activityDates.length === 0) {
+            return null;
+        }
+        // Calculate daily streak
+        let dailyCurrent = 0;
+        let dailyLongest = 0;
+        let tempStreak = 0;
+        let lastDate = null;
+        for (const date of activityDates) {
+            if (!lastDate) {
+                tempStreak = 1;
+            }
+            else {
+                // Calculate days between dates
+                const datesBetween = shaxpir_common_1.Time.datesBetween(lastDate, date);
+                const daysBetween = datesBetween.length - 1; // Subtract 1 because datesBetween includes both dates
+                if (daysBetween === 1) {
+                    tempStreak++;
+                }
+                else {
+                    // Streak broken
+                    dailyLongest = Math.max(dailyLongest, tempStreak);
+                    tempStreak = 1;
+                }
+            }
+            lastDate = date;
+        }
+        // Check if current streak is still active (includes today or yesterday)
+        if (lastDate) {
+            const datesSinceLastActivity = shaxpir_common_1.Time.datesBetween(lastDate, today);
+            const daysSinceLastActivity = datesSinceLastActivity.length - 1;
+            if (daysSinceLastActivity <= 1) {
+                dailyCurrent = tempStreak;
+            }
+        }
+        dailyLongest = Math.max(dailyLongest, tempStreak);
+        // Calculate weekly streak (at least one activity per week)
+        let weeklyCurrent = 0;
+        let weeklyStreak = 0;
+        // Check for weekly continuity - if there's activity within each 7-day window
+        for (let i = activityDates.length - 1; i >= 0; i--) {
+            const currentDate = activityDates[i];
+            // For the most recent date, start counting
+            if (i === activityDates.length - 1) {
+                // Check if this was within the last 7 days
+                const daysFromToday = shaxpir_common_1.Time.datesBetween(currentDate, today).length - 1;
+                if (daysFromToday <= 7) {
+                    weeklyStreak = 1;
+                    weeklyCurrent = 1;
+                }
+            }
+            else {
+                // Check if there's a gap of more than 7 days
+                const nextDate = activityDates[i + 1];
+                const daysBetween = shaxpir_common_1.Time.datesBetween(currentDate, nextDate).length - 1;
+                if (daysBetween <= 7) {
+                    weeklyStreak++;
+                    if (weeklyCurrent > 0) {
+                        weeklyCurrent = weeklyStreak;
+                    }
+                }
+                else {
+                    // Weekly streak broken
+                    break;
+                }
+            }
+        }
+        // Calculate monthly streak
+        // Extract YYYY-MM from CompactDate (format: YYYY-MM-DD)
+        const monthlyActivity = new Set();
+        for (const date of activityDates) {
+            const month = date.substring(0, 7); // Extract YYYY-MM
+            monthlyActivity.add(month);
+        }
+        const sortedMonths = Array.from(monthlyActivity).sort();
+        let monthlyCurrent = 0;
+        let monthlyStreak = 0;
+        let lastMonth = null;
+        for (const month of sortedMonths) {
+            if (!lastMonth) {
+                monthlyStreak = 1;
+            }
+            else {
+                // Check if consecutive month
+                const [lastYear, lastMonthNum] = lastMonth.split('-').map(Number);
+                const [currentYear, currentMonthNum] = month.split('-').map(Number);
+                if ((currentYear === lastYear && currentMonthNum === lastMonthNum + 1) ||
+                    (currentYear === lastYear + 1 && lastMonthNum === 12 && currentMonthNum === 1)) {
+                    monthlyStreak++;
+                }
+                else {
+                    monthlyStreak = 1;
+                }
+            }
+            lastMonth = month;
+        }
+        // Check if current month streak is active
+        const currentMonth = today.substring(0, 7); // Extract YYYY-MM
+        const lastActiveMonth = sortedMonths[sortedMonths.length - 1];
+        const lastMonthDate = shaxpir_common_1.Time.plus(today, -30, 'days');
+        const previousMonth = shaxpir_common_1.Time.dateFrom(lastMonthDate).substring(0, 7);
+        if (lastActiveMonth === currentMonth || lastActiveMonth === previousMonth) {
+            monthlyCurrent = monthlyStreak;
+        }
+        // Get week string for last activity (ISO week format)
+        const getWeekString = (date) => {
+            // Simple week calculation: YYYY-Www where ww is week of year
+            const [year, month, day] = date.split('-').map(Number);
+            const dateObj = new Date(year, month - 1, day);
+            const startOfYear = new Date(year, 0, 1);
+            const dayOfYear = Math.floor((dateObj.getTime() - startOfYear.getTime()) / (24 * 60 * 60 * 1000)) + 1;
+            const weekNumber = Math.ceil(dayOfYear / 7);
+            return `${year}-W${weekNumber.toString().padStart(2, '0')}`;
+        };
+        // We know lastDate has a value since activityDates.length > 0
+        const finalLastDate = lastDate || activityDates[activityDates.length - 1];
+        return {
+            daily: {
+                current: dailyCurrent,
+                longest: dailyLongest
+            },
+            weekly: {
+                current: weeklyCurrent
+            },
+            monthly: {
+                current: monthlyCurrent
+            },
+            last_activity: {
+                date: finalLastDate,
+                week: getWeekString(finalLastDate),
+                month: finalLastDate.substring(0, 7)
+            },
+            total_days: activityDates.length
+        };
+    }
+}
+exports.Streaks = Streaks;

package/dist/models/index.d.ts

@@ -21,6 +21,7 @@ export * from './Progress';
 export * from './Review';
 export * from './Session';
 export * from './Social';
+export * from './Streaks';
 export * from './Term';
 export * from './User';
 export * from './Workspace';

package/dist/models/index.js

@@ -38,6 +38,7 @@ __exportStar(require("./Progress"), exports);
 __exportStar(require("./Review"), exports);
 __exportStar(require("./Session"), exports);
 __exportStar(require("./Social"), exports);
+__exportStar(require("./Streaks"), exports);
 __exportStar(require("./Term"), exports);
 __exportStar(require("./User"), exports);
 __exportStar(require("./Workspace"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaxpir/duiduidui-models",
-  "version": "1.7.2",
+  "version": "1.7.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/shaxpir/duiduidui-models"