@shaxpir/duiduidui-models 1.6.18 → 1.7.0

package/dist/models/Progress.d.ts

@@ -1,4 +1,5 @@
 import { Doc } from '@shaxpir/sharedb/lib/client';
+import { CompactDate } from "@shaxpir/shaxpir-common";
 import { ShareSync } from '../repo';
 import { Bounds } from './BayesianScore';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
@@ -7,9 +8,28 @@ export interface UncertainValue {
     uncertainty: number;
     bounds: Bounds;
 }
+export interface StreakData {
+    daily: {
+        current: number;
+        longest: number;
+    };
+    weekly: {
+        current: number;
+    };
+    monthly: {
+        current: number;
+    };
+    last_activity: {
+        date: CompactDate;
+        week: string;
+        month: string;
+    };
+    total_days: number;
+}
 export interface ProgressPayload {
     skill_level: UncertainValue;
     cognitive_load: number;
+    streaks?: StreakData;
 }
 export interface ProgressBody extends ContentBody {
     meta: ContentMeta;
@@ -33,4 +53,6 @@ export declare class Progress extends Content {
     setSkillLevelLowerBound(lowerBound: number): void;
     setSkillLevelUpperBound(upperBound: number): void;
     setCognitiveLoad(value: number): void;
+    getStreaks(): StreakData | undefined;
+    setStreaks(streaks: StreakData): void;
 }

package/dist/models/Progress.js

@@ -122,5 +122,17 @@ class Progress extends Content_1.Content {
             batch.commit();
         }
     }
+    getStreaks() {
+        this.checkDisposed("Progress.getStreaks");
+        return this.payload.streaks ? shaxpir_common_1.Struct.clone(this.payload.streaks) : undefined;
+    }
+    setStreaks(streaks) {
+        this.checkDisposed("Progress.setStreaks");
+        if (!shaxpir_common_1.Struct.equals(this.payload.streaks, streaks)) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'streaks'], streaks);
+            batch.commit();
+        }
+    }
 }
 exports.Progress = Progress;

package/dist/models/Session.d.ts

@@ -1,8 +1,54 @@
 import { Doc } from '@shaxpir/sharedb/lib/client';
 import { MultiTime } from "@shaxpir/shaxpir-common";
 import { ShareSync } from '../repo';
+import { ConditionFilters } from './Condition';
 import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
 import { Review } from './Review';
+import { UncertainValue } from './Progress';
+export interface SessionConfig {
+    version: number;
+    constraints?: {
+        card_limit?: number | null;
+        time_limit?: number;
+    };
+    selection?: {
+        difficulty_ramp?: number;
+        filters?: ConditionFilters;
+        strategy?: {
+            name: string;
+            version?: string;
+            constants?: Record<string, any>;
+        };
+    };
+    display?: {
+        show_pinyin?: boolean;
+        auto_play_speech?: boolean;
+    };
+}
+export interface SessionMetrics {
+    skill_level: UncertainValue;
+    cognitive_load: number;
+    theta_distribution: {
+        A: number;
+        B: number;
+        C: number;
+        D: number;
+        F: number;
+    };
+    streaks: {
+        daily: {
+            current: number;
+            longest: number;
+        };
+        weekly: {
+            current: number;
+        };
+        monthly: {
+            current: number;
+        };
+        total_days: number;
+    };
+}
 export interface SessionPayload {
     start: MultiTime;
     end: MultiTime;
@@ -11,6 +57,12 @@ export interface SessionPayload {
     duration_minutes: number;
     reviews: Review[];
     review_count: number;
+    config?: SessionConfig;
+    metrics?: {
+        before?: SessionMetrics;
+        after?: SessionMetrics;
+    };
+    is_complete?: boolean;
 }
 export interface SessionBody extends ContentBody {
     meta: ContentMeta;
@@ -32,5 +84,14 @@ export declare class Session extends Content {
     get reviews(): Review[];
     get reviewCount(): number;
     addReview(review: Review): void;
+    get config(): SessionConfig | undefined;
+    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;
+    isActive(): boolean;
     modelUpdated(): Promise<void>;
 }

package/dist/models/Session.js

@@ -106,6 +106,62 @@ class Session extends Content_1.Content {
         batch.setPathValue(['payload', 'review_count'], this._reviewsView.length);
         batch.commit();
     }
+    get config() {
+        this.checkDisposed("Session.config");
+        return this.payload.config;
+    }
+    setConfig(config) {
+        this.checkDisposed("Session.setConfig");
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'config'], config);
+        batch.commit();
+    }
+    get isComplete() {
+        this.checkDisposed("Session.isComplete");
+        return this.payload.is_complete || false;
+    }
+    markComplete() {
+        this.checkDisposed("Session.markComplete");
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'is_complete'], true);
+        batch.commit();
+    }
+    get metricsBefore() {
+        this.checkDisposed("Session.metricsBefore");
+        return this.payload.metrics?.before;
+    }
+    setMetricsBefore(metrics) {
+        this.checkDisposed("Session.setMetricsBefore");
+        const batch = new Operation_1.BatchOperation(this);
+        if (!this.payload.metrics) {
+            batch.setPathValue(['payload', 'metrics'], {});
+        }
+        batch.setPathValue(['payload', 'metrics', 'before'], metrics);
+        batch.commit();
+    }
+    get metricsAfter() {
+        this.checkDisposed("Session.metricsAfter");
+        return this.payload.metrics?.after;
+    }
+    setMetricsAfter(metrics) {
+        this.checkDisposed("Session.setMetricsAfter");
+        const batch = new Operation_1.BatchOperation(this);
+        if (!this.payload.metrics) {
+            batch.setPathValue(['payload', 'metrics'], {});
+        }
+        batch.setPathValue(['payload', 'metrics', 'after'], metrics);
+        batch.commit();
+    }
+    isActive() {
+        this.checkDisposed("Session.isActive");
+        // Session is active if not completed and not expired
+        if (this.isComplete) {
+            return false;
+        }
+        const now = shaxpir_common_1.ClockService.getClock().now();
+        const fifteenMinutesAgo = shaxpir_common_1.Time.plus(now.utc_time, -15, 'minutes');
+        return shaxpir_common_1.Time.isDateTimeAfter(this.updatedAt.utc_time, fifteenMinutesAgo);
+    }
     async modelUpdated() {
         this.checkDisposed("Session.modelUpdated");
         await super.modelUpdated();

package/dist/repo/ShareSync.js

@@ -156,7 +156,17 @@ class ShareSync {
         }
     }
     createConnectionWithDurableStore(socket, options) {
-        return new client_1.Connection(socket, {
+        const shareSync = this;
+        // Create a wrapper callback that ensures it's called even when offline
+        let readyCallbackInvoked = false;
+        const wrappedCallback = options.onReadyCallback ? function () {
+            if (!readyCallbackInvoked) {
+                readyCallbackInvoked = true;
+                shareSync._debug && console.log('[ShareSync] DurableStore ready, invoking onReadyCallback');
+                options.onReadyCallback();
+            }
+        } : undefined;
+        const connection = new client_1.Connection(socket, {
             durableStore: {
                 storage: this._storage,
                 debug: this._debug,
@@ -170,9 +180,20 @@ class ShareSync {
                     }
                     return null;
                 },
-                onReadyCallback: options.onReadyCallback
+                onReadyCallback: wrappedCallback
             }
         });
+        // Add a fallback timeout to ensure the callback fires even if the DurableStore
+        // ready event doesn't properly trigger when offline
+        if (wrappedCallback && !shareSync._socketIsOpen) {
+            setTimeout(function () {
+                if (!readyCallbackInvoked) {
+                    console.warn('[ShareSync] Socket offline - forcing onReadyCallback after timeout');
+                    wrappedCallback();
+                }
+            }, 100); // Small delay to allow normal initialization first
+        }
+        return connection;
     }
     async initializeDurableStore(options) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaxpir/duiduidui-models",
-  "version": "1.6.18",
+  "version": "1.7.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/shaxpir/duiduidui-models"
@@ -21,7 +21,6 @@
     "@shaxpir/shaxpir-common": "1.4.0",
     "ot-json1": "1.0.1",
     "ot-text-unicode": "4.0.0",
-    "react-native-popover-view": "^6.1.0",
     "reconnecting-websocket": "4.4.0"
   },
   "devDependencies": {