@shaxpir/duiduidui-models 1.9.10 → 1.9.12

package/dist/models/Device.d.ts

@@ -4,6 +4,7 @@ import { ShareSync } from '../repo';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
 import { ConditionFilters } from './Condition';
 import { BuiltInDbState, DatabaseVersion } from '../util/Database';
+import { SearchHistory, SearchState } from './SearchState';
 export interface LastSync {
     at_utc_time: CompactDateTime | null;
 }
@@ -37,6 +38,7 @@ export interface DevicePayload {
     download_queue?: DownloadQueueItem[];
     upload_queue?: UploadQueueItem[];
     builtin_db?: BuiltInDbState;
+    search_history: SearchHistory;
 }
 export interface DeviceBody extends ContentBody {
     meta: ContentMeta;
@@ -77,5 +79,45 @@ export declare class Device extends Content {
     updateUploadQueueItem(predicate: (item: UploadQueueItem) => boolean, updates: Partial<BaseQueueItem>): void;
     addImageToUploadQueue(imageId: ContentId): void;
     removeImageFromUploadQueue(imageId: ContentId): void;
+    /**
+     * Gets the current search history.
+     */
+    get searchHistory(): SearchHistory;
+    /**
+     * Gets the current search state (at the cursor position), or undefined if history is empty.
+     */
+    get currentSearchState(): SearchState | undefined;
+    /**
+     * Returns true if back navigation is possible.
+     * Only returns true if the previous entry is non-empty (has query or conditions).
+     */
+    get canGoBack(): boolean;
+    /**
+     * Returns true if forward navigation is possible.
+     */
+    get canGoForward(): boolean;
+    /**
+     * Pushes a new search state onto the history stack.
+     * - Deduplicates: won't push if identical to current state
+     * - Discards forward history (entries after cursor)
+     * - Respects max entries limit (drops oldest when full)
+     *
+     * @returns The new search state at the cursor, or undefined if deduplicated
+     */
+    pushSearchState(state: SearchState): SearchState | undefined;
+    /**
+     * Navigates back in search history.
+     * @returns The search state at the new cursor position, or undefined if can't go back
+     */
+    goBack(): SearchState | undefined;
+    /**
+     * Navigates forward in search history.
+     * @returns The search state at the new cursor position, or undefined if can't go forward
+     */
+    goForward(): SearchState | undefined;
+    /**
+     * Clears the entire search history stack.
+     */
+    clearSearchHistory(): void;
 }
 export {};

package/dist/models/Device.js

@@ -7,6 +7,7 @@ const ArrayView_1 = require("./ArrayView");
 const Content_1 = require("./Content");
 const ContentKind_1 = require("./ContentKind");
 const Operation_1 = require("./Operation");
+const SearchState_1 = require("./SearchState");
 class Device extends Content_1.Content {
     static create(userId, deviceId) {
         const now = shaxpir_common_1.ClockService.getClock().now();
@@ -29,7 +30,8 @@ class Device extends Content_1.Content {
                     download_status: 'none',
                     last_check: null,
                     last_error: null
-                }
+                },
+                search_history: (0, SearchState_1.createEmptySearchHistory)()
             }
         });
     }
@@ -244,5 +246,127 @@ class Device extends Content_1.Content {
     removeImageFromUploadQueue(imageId) {
         this.removeFromUploadQueue(item => item.type === 'image' && item.image_id === imageId);
     }
+    // Search History Methods
+    /**
+     * Gets the current search history.
+     */
+    get searchHistory() {
+        this.checkDisposed("Device.searchHistory");
+        return this.payload.search_history;
+    }
+    /**
+     * Gets the current search state (at the cursor position), or undefined if history is empty.
+     */
+    get currentSearchState() {
+        this.checkDisposed("Device.currentSearchState");
+        const history = this.searchHistory;
+        if (history.cursor < 0 || history.cursor >= history.entries.length) {
+            return undefined;
+        }
+        return history.entries[history.cursor];
+    }
+    /**
+     * Returns true if back navigation is possible.
+     * Only returns true if the previous entry is non-empty (has query or conditions).
+     */
+    get canGoBack() {
+        this.checkDisposed("Device.canGoBack");
+        const history = this.searchHistory;
+        if (history.cursor <= 0)
+            return false;
+        // Check if the entry we'd navigate to is non-empty
+        const prevEntry = history.entries[history.cursor - 1];
+        return !(0, SearchState_1.isEmptySearchState)(prevEntry);
+    }
+    /**
+     * Returns true if forward navigation is possible.
+     */
+    get canGoForward() {
+        this.checkDisposed("Device.canGoForward");
+        const history = this.searchHistory;
+        return history.cursor < history.entries.length - 1;
+    }
+    /**
+     * Pushes a new search state onto the history stack.
+     * - Deduplicates: won't push if identical to current state
+     * - Discards forward history (entries after cursor)
+     * - Respects max entries limit (drops oldest when full)
+     *
+     * @returns The new search state at the cursor, or undefined if deduplicated
+     */
+    pushSearchState(state) {
+        this.checkDisposed("Device.pushSearchState");
+        const history = this.searchHistory;
+        // Deduplicate: don't push if identical to current state
+        const currentState = history.cursor >= 0 && history.cursor < history.entries.length
+            ? history.entries[history.cursor]
+            : undefined;
+        if ((0, SearchState_1.areSearchStatesEqual)(state, currentState)) {
+            return undefined;
+        }
+        // Build new entries array
+        // Discard any entries after the current cursor (browser-style)
+        let newEntries = history.cursor >= 0
+            ? history.entries.slice(0, history.cursor + 1)
+            : [];
+        // Add the new state
+        newEntries.push(state);
+        // Enforce max entries limit - drop oldest entries
+        let newCursor = newEntries.length - 1;
+        if (newEntries.length > SearchState_1.SEARCH_HISTORY_MAX_ENTRIES) {
+            const overflow = newEntries.length - SearchState_1.SEARCH_HISTORY_MAX_ENTRIES;
+            newEntries = newEntries.slice(overflow);
+            newCursor = newEntries.length - 1;
+        }
+        // Commit the update
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'search_history'], {
+            entries: newEntries,
+            cursor: newCursor
+        });
+        batch.commit();
+        return state;
+    }
+    /**
+     * Navigates back in search history.
+     * @returns The search state at the new cursor position, or undefined if can't go back
+     */
+    goBack() {
+        this.checkDisposed("Device.goBack");
+        if (!this.canGoBack) {
+            return undefined;
+        }
+        const history = this.searchHistory;
+        const newCursor = history.cursor - 1;
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'search_history', 'cursor'], newCursor);
+        batch.commit();
+        return history.entries[newCursor];
+    }
+    /**
+     * Navigates forward in search history.
+     * @returns The search state at the new cursor position, or undefined if can't go forward
+     */
+    goForward() {
+        this.checkDisposed("Device.goForward");
+        if (!this.canGoForward) {
+            return undefined;
+        }
+        const history = this.searchHistory;
+        const newCursor = history.cursor + 1;
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'search_history', 'cursor'], newCursor);
+        batch.commit();
+        return history.entries[newCursor];
+    }
+    /**
+     * Clears the entire search history stack.
+     */
+    clearSearchHistory() {
+        this.checkDisposed("Device.clearSearchHistory");
+        const batch = new Operation_1.BatchOperation(this);
+        batch.setPathValue(['payload', 'search_history'], (0, SearchState_1.createEmptySearchHistory)());
+        batch.commit();
+    }
 }
 exports.Device = Device;

package/dist/models/SearchState.d.ts

@@ -0,0 +1,50 @@
+import { ConditionFilters } from './Condition';
+/**
+ * Represents the data portion of a search state.
+ * This is the shareable/persistable part of a search - it excludes
+ * transient UI state like SearchReason.
+ *
+ * Used for:
+ * - Search history entries in the Device model
+ * - Sharing search states between client and server
+ * - Cache keys and comparison
+ */
+export interface SearchState {
+    query?: string;
+    senseRank?: number;
+    conditions?: ConditionFilters;
+}
+/**
+ * Maximum number of entries in the search history stack.
+ * When this limit is reached, the oldest entry is dropped.
+ */
+export declare const SEARCH_HISTORY_MAX_ENTRIES = 50;
+/**
+ * Search history with browser-style back/forward navigation.
+ *
+ * - `entries`: Stack of search states
+ * - `cursor`: Current position in the stack (0-indexed)
+ *
+ * Navigation behavior:
+ * - Back: decrements cursor (if cursor > 0)
+ * - Forward: increments cursor (if cursor < entries.length - 1)
+ * - New search: discards entries after cursor, pushes new entry, cursor moves to end
+ * - Clear: empties the entire stack
+ */
+export interface SearchHistory {
+    entries: SearchState[];
+    cursor: number;
+}
+/**
+ * Creates an empty search history.
+ */
+export declare function createEmptySearchHistory(): SearchHistory;
+/**
+ * Checks if two SearchState objects are equivalent.
+ * Used for deduplication when pushing to history.
+ */
+export declare function areSearchStatesEqual(a: SearchState | undefined, b: SearchState | undefined): boolean;
+/**
+ * Checks if a SearchState is empty (no query, no conditions).
+ */
+export declare function isEmptySearchState(state: SearchState | undefined): boolean;

package/dist/models/SearchState.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEARCH_HISTORY_MAX_ENTRIES = void 0;
+exports.createEmptySearchHistory = createEmptySearchHistory;
+exports.areSearchStatesEqual = areSearchStatesEqual;
+exports.isEmptySearchState = isEmptySearchState;
+/**
+ * Maximum number of entries in the search history stack.
+ * When this limit is reached, the oldest entry is dropped.
+ */
+exports.SEARCH_HISTORY_MAX_ENTRIES = 50;
+/**
+ * Creates an empty search history.
+ */
+function createEmptySearchHistory() {
+    return {
+        entries: [],
+        cursor: -1
+    };
+}
+/**
+ * Checks if two SearchState objects are equivalent.
+ * Used for deduplication when pushing to history.
+ */
+function areSearchStatesEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    // Compare query (normalize empty string to undefined)
+    const queryA = a.query?.trim() || undefined;
+    const queryB = b.query?.trim() || undefined;
+    if (queryA !== queryB)
+        return false;
+    // Compare senseRank
+    if (a.senseRank !== b.senseRank)
+        return false;
+    // Compare conditions using JSON serialization (with sorted keys for consistency)
+    const conditionsA = a.conditions ? JSON.stringify(sortConditions(a.conditions)) : undefined;
+    const conditionsB = b.conditions ? JSON.stringify(sortConditions(b.conditions)) : undefined;
+    if (conditionsA !== conditionsB)
+        return false;
+    return true;
+}
+/**
+ * Sorts condition arrays for consistent comparison.
+ */
+function sortConditions(conditions) {
+    const sorted = {};
+    if (conditions.any?.length) {
+        sorted.any = [...conditions.any].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    }
+    if (conditions.all?.length) {
+        sorted.all = [...conditions.all].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    }
+    if (conditions.none?.length) {
+        sorted.none = [...conditions.none].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    }
+    return sorted;
+}
+/**
+ * Checks if a SearchState is empty (no query, no conditions).
+ */
+function isEmptySearchState(state) {
+    if (!state)
+        return true;
+    return !state.query?.trim() &&
+        !state.conditions?.any?.length &&
+        !state.conditions?.all?.length &&
+        !state.conditions?.none?.length;
+}

package/dist/models/index.d.ts

@@ -19,6 +19,7 @@ export * from './Phrase';
 export * from './Profile';
 export * from './Progress';
 export * from './Review';
+export * from './SearchState';
 export * from './Session';
 export * from './SkillLevel';
 export * from './Social';

package/dist/models/index.js

@@ -36,6 +36,7 @@ __exportStar(require("./Phrase"), exports);
 __exportStar(require("./Profile"), exports);
 __exportStar(require("./Progress"), exports);
 __exportStar(require("./Review"), exports);
+__exportStar(require("./SearchState"), exports);
 __exportStar(require("./Session"), exports);
 __exportStar(require("./SkillLevel"), exports);
 __exportStar(require("./Social"), exports);

package/package.json

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