@shaxpir/duiduidui-models 1.5.14 → 1.6.0

package/dist/models/Condition.d.ts

@@ -72,4 +72,52 @@ export declare const Condition: {
     intermediate: () => DifficultyCondition;
     advanced: () => DifficultyCondition;
     expert: () => DifficultyCondition;
+    /**
+     * Check if starred condition is required (in 'all' section)
+     */
+    requiresStarred: (filters?: ConditionFilters) => boolean;
+    /**
+     * Check if starred condition is optional (in 'any' section)
+     */
+    allowsStarred: (filters?: ConditionFilters) => boolean;
+    /**
+     * Check if starred condition is excluded (in 'none' section)
+     */
+    excludesStarred: (filters?: ConditionFilters) => boolean;
+    /**
+     * Check if starred condition exists anywhere in filters
+     */
+    hasStarred: (filters?: ConditionFilters) => boolean;
+    /**
+     * Check if a specific tag is required (in 'all' section)
+     */
+    requiresTag: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    /**
+     * Check if a specific tag is optional (in 'any' section)
+     */
+    allowsTag: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    /**
+     * Check if a specific tag is excluded (in 'none' section)
+     */
+    excludesTag: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    /**
+     * Check if a specific grade is required (in 'all' section)
+     */
+    requiresGrade: (filters: ConditionFilters | undefined, grade: "A" | "B" | "C" | "D" | "F") => boolean;
+    /**
+     * Check if any condition of a specific type exists in filters
+     */
+    hasConditionType: (filters: ConditionFilters | undefined, type: string) => boolean;
+    /**
+     * Validate filters for logical inconsistencies
+     * Returns an array of error messages, empty if valid
+     */
+    validate: (filters?: ConditionFilters) => string[];
+    hasStarredInAll: (filters?: ConditionFilters) => boolean;
+    hasStarredInAny: (filters?: ConditionFilters) => boolean;
+    hasStarredInNone: (filters?: ConditionFilters) => boolean;
+    hasTagInAll: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    hasTagInAny: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    hasTagInNone: (filters: ConditionFilters | undefined, tag: string) => boolean;
+    hasGradeInAll: (filters: ConditionFilters | undefined, grade: "A" | "B" | "C" | "D" | "F") => boolean;
 };

package/dist/models/Condition.js

@@ -37,5 +37,106 @@ exports.Condition = {
     elementary: () => ({ type: 'difficulty', min: 100, max: 500 }), // Easy
     intermediate: () => ({ type: 'difficulty', min: 500, max: 1500 }), // Medium
     advanced: () => ({ type: 'difficulty', min: 1500, max: 3000 }), // Hard
-    expert: () => ({ type: 'difficulty', min: 3000 }) // Very hard
+    expert: () => ({ type: 'difficulty', min: 3000 }), // Very hard
+    // Helper methods to check if conditions are present in filters
+    /**
+     * Check if starred condition is required (in 'all' section)
+     */
+    requiresStarred: (filters) => {
+        return !!(filters?.all?.some(c => c.type === 'starred' && c.value === true));
+    },
+    /**
+     * Check if starred condition is optional (in 'any' section)
+     */
+    allowsStarred: (filters) => {
+        return !!(filters?.any?.some(c => c.type === 'starred' && c.value === true));
+    },
+    /**
+     * Check if starred condition is excluded (in 'none' section)
+     */
+    excludesStarred: (filters) => {
+        return !!(filters?.none?.some(c => c.type === 'starred' && c.value === true));
+    },
+    /**
+     * Check if starred condition exists anywhere in filters
+     */
+    hasStarred: (filters) => {
+        return exports.Condition.requiresStarred(filters) ||
+            exports.Condition.allowsStarred(filters) ||
+            exports.Condition.excludesStarred(filters);
+    },
+    /**
+     * Check if a specific tag is required (in 'all' section)
+     */
+    requiresTag: (filters, tag) => {
+        return !!(filters?.all?.some(c => c.type === 'tag' && c.tag === tag));
+    },
+    /**
+     * Check if a specific tag is optional (in 'any' section)
+     */
+    allowsTag: (filters, tag) => {
+        return !!(filters?.any?.some(c => c.type === 'tag' && c.tag === tag));
+    },
+    /**
+     * Check if a specific tag is excluded (in 'none' section)
+     */
+    excludesTag: (filters, tag) => {
+        return !!(filters?.none?.some(c => c.type === 'tag' && c.tag === tag));
+    },
+    /**
+     * Check if a specific grade is required (in 'all' section)
+     */
+    requiresGrade: (filters, grade) => {
+        return !!(filters?.all?.some(c => c.type === 'grade' && c.grade === grade));
+    },
+    /**
+     * Check if any condition of a specific type exists in filters
+     */
+    hasConditionType: (filters, type) => {
+        return !!(filters?.all?.some(c => c.type === type) ||
+            filters?.any?.some(c => c.type === type) ||
+            filters?.none?.some(c => c.type === type));
+    },
+    /**
+     * Validate filters for logical inconsistencies
+     * Returns an array of error messages, empty if valid
+     */
+    validate: (filters) => {
+        if (!filters)
+            return [];
+        const errors = [];
+        // Check for contradictory starred conditions
+        if (exports.Condition.requiresStarred(filters) && exports.Condition.excludesStarred(filters)) {
+            errors.push('Cannot require starred items and exclude starred items at the same time');
+        }
+        // Check for contradictory tags
+        const allTags = filters.all?.filter(c => c.type === 'tag').map(c => c.tag) || [];
+        const noneTags = filters.none?.filter(c => c.type === 'tag').map(c => c.tag) || [];
+        allTags.forEach(tag => {
+            if (noneTags.includes(tag)) {
+                errors.push(`Tag "${tag}" cannot be both required and excluded`);
+            }
+        });
+        // Check for contradictory grades
+        const allGrades = filters.all?.filter(c => c.type === 'grade').map(c => c.grade) || [];
+        const noneGrades = filters.none?.filter(c => c.type === 'grade').map(c => c.grade) || [];
+        allGrades.forEach(grade => {
+            if (noneGrades.includes(grade)) {
+                errors.push(`Grade "${grade}" cannot be both required and excluded`);
+            }
+        });
+        // Check for multiple required grades (can only have one grade at a time)
+        if (allGrades.length > 1) {
+            errors.push(`Cannot require multiple grades: ${allGrades.join(', ')} - an item can only have one grade`);
+        }
+        return errors;
+    },
+    // Backward compatibility aliases (deprecated - use requiresStarred/allowsStarred/excludesStarred instead)
+    hasStarredInAll: (filters) => exports.Condition.requiresStarred(filters),
+    hasStarredInAny: (filters) => exports.Condition.allowsStarred(filters),
+    hasStarredInNone: (filters) => exports.Condition.excludesStarred(filters),
+    hasTagInAll: (filters, tag) => exports.Condition.requiresTag(filters, tag),
+    hasTagInAny: (filters, tag) => exports.Condition.allowsTag(filters, tag),
+    hasTagInNone: (filters, tag) => exports.Condition.excludesTag(filters, tag),
+    hasGradeInAll: (filters, grade) => exports.Condition.requiresGrade(filters, grade)
 };

package/dist/models/Content.d.ts

@@ -4,7 +4,7 @@ import { ShareSync } from '../repo';
 import { BillingPayload } from './Billing';
 import { ContentKind } from './ContentKind';
 import { DevicePayload } from './Device';
-import { MediaPayload } from './Media';
+import { ImagePayload } from './Image';
 import { MetricPayload } from './Metric';
 import { Model } from './Model';
 import { ProfilePayload } from "./Profile";
@@ -36,7 +36,7 @@ export interface ContentMeta {
     created_at: MultiTime;
     updated_at: MultiTime;
 }
-export type ContentPayload = BillingPayload | DevicePayload | MediaPayload | MetricPayload | ProfilePayload | ProgressPayload | SessionPayload | TermPayload | UserPayload | WorkspacePayload;
+export type ContentPayload = BillingPayload | DevicePayload | ImagePayload | MetricPayload | ProfilePayload | ProgressPayload | SessionPayload | TermPayload | UserPayload | WorkspacePayload;
 export declare abstract class Content extends Model {
     static ID_LENGTH: number;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);

package/dist/models/ContentKind.d.ts

@@ -7,7 +7,7 @@ export declare enum ContentKind {
     SESSION = "session",
     TERM = "term",
     USER = "user",
-    MEDIA = "media",
+    IMAGE = "image",
     WORKSPACE = "workspace",
     MANIFEST = "manifest"
 }

package/dist/models/ContentKind.js

@@ -13,7 +13,7 @@ var ContentKind;
     ContentKind["SESSION"] = "session";
     ContentKind["TERM"] = "term";
     ContentKind["USER"] = "user";
-    ContentKind["MEDIA"] = "media";
+    ContentKind["IMAGE"] = "image";
     ContentKind["WORKSPACE"] = "workspace";
     // These are used in the ShareDB system, but for internal bookkeeping, not for Content subclasses.
     ContentKind["MANIFEST"] = "manifest";

package/dist/models/Device.d.ts

@@ -6,27 +6,42 @@ import { ConditionFilters } from './Condition';
 export interface LastSync {
     at_utc_time: CompactDateTime | null;
 }
-export interface AudioDownloadQueueItem {
-    text: string;
+interface BaseQueueItem {
     added_at: CompactDateTime;
     retry_count: number;
     next_retry_at?: CompactDateTime;
     last_error?: string;
 }
+export interface AudioDownloadQueueItem extends BaseQueueItem {
+    type: 'audio';
+    text: string;
+}
+export interface ImageDownloadQueueItem extends BaseQueueItem {
+    type: 'image';
+    image_id: ContentId;
+}
+export type DownloadQueueItem = AudioDownloadQueueItem | ImageDownloadQueueItem;
+export interface ImageUploadQueueItem extends BaseQueueItem {
+    type: 'image';
+    image_id: ContentId;
+}
+export type UploadQueueItem = ImageUploadQueueItem;
 export interface DevicePayload {
     last_sync?: LastSync;
     chinese_font?: string;
     raw_search_text?: string;
     star_filter?: boolean;
     conditions?: ConditionFilters;
-    audio_download_queue?: AudioDownloadQueueItem[];
+    download_queue?: DownloadQueueItem[];
+    upload_queue?: UploadQueueItem[];
 }
 export interface DeviceBody extends ContentBody {
     meta: ContentMeta;
     payload: DevicePayload;
 }
 export declare class Device extends Content {
-    private _audioDownloadQueueView;
+    private _downloadQueueView;
+    private _uploadQueueView;
     static create(userId: ContentId, deviceId: ContentId): Device;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
     get payload(): DevicePayload;
@@ -34,9 +49,19 @@ export declare class Device extends Content {
     setLastSyncAtUtcTime(value: CompactDateTime): void;
     get chineseFont(): string;
     setChineseFont(value: string): void;
-    get audioDownloadQueue(): AudioDownloadQueueItem[];
-    get audioDownloadQueueLength(): number;
-    addToAudioDownloadQueue(text: string): void;
-    removeFromAudioDownloadQueue(text: string): void;
-    updateAudioDownloadQueueItem(text: string, updates: Partial<AudioDownloadQueueItem>): void;
+    get downloadQueue(): DownloadQueueItem[];
+    get downloadQueueLength(): number;
+    addToDownloadQueue(item: AudioDownloadQueueItem | ImageDownloadQueueItem): void;
+    removeFromDownloadQueue(predicate: (item: DownloadQueueItem) => boolean): void;
+    updateDownloadQueueItem(predicate: (item: DownloadQueueItem) => boolean, updates: Partial<BaseQueueItem>): void;
+    addAudioToDownloadQueue(text: string): void;
+    removeAudioFromDownloadQueue(text: string): void;
+    get uploadQueue(): UploadQueueItem[];
+    get uploadQueueLength(): number;
+    addToUploadQueue(item: UploadQueueItem): void;
+    removeFromUploadQueue(predicate: (item: UploadQueueItem) => boolean): void;
+    updateUploadQueueItem(predicate: (item: UploadQueueItem) => boolean, updates: Partial<BaseQueueItem>): void;
+    addImageToUploadQueue(imageId: ContentId): void;
+    removeImageFromUploadQueue(imageId: ContentId): void;
 }
+export {};

package/dist/models/Device.js

@@ -21,13 +21,15 @@ class Device extends Content_1.Content {
             },
             payload: {
                 last_sync: { at_utc_time: null },
-                audio_download_queue: []
+                download_queue: [],
+                upload_queue: []
             }
         });
     }
     constructor(doc, shouldAcquire, shareSync) {
         super(doc, shouldAcquire, shareSync);
-        this._audioDownloadQueueView = new ArrayView_1.ArrayView(this, ['payload', 'audio_download_queue']);
+        this._downloadQueueView = new ArrayView_1.ArrayView(this, ['payload', 'download_queue']);
+        this._uploadQueueView = new ArrayView_1.ArrayView(this, ['payload', 'upload_queue']);
     }
     get payload() {
         this.checkDisposed("Device.payload");
@@ -57,50 +59,120 @@ class Device extends Content_1.Content {
             batch.commit();
         }
     }
-    get audioDownloadQueue() {
-        this.checkDisposed("Device.audioDownloadQueue");
-        return this._audioDownloadQueueView.values;
+    // Download Queue Methods
+    get downloadQueue() {
+        this.checkDisposed("Device.downloadQueue");
+        return this._downloadQueueView.values;
     }
-    get audioDownloadQueueLength() {
-        this.checkDisposed("Device.audioDownloadQueueLength");
-        return this._audioDownloadQueueView.length;
+    get downloadQueueLength() {
+        this.checkDisposed("Device.downloadQueueLength");
+        return this._downloadQueueView.length;
     }
-    addToAudioDownloadQueue(text) {
-        this.checkDisposed("Device.addToAudioDownloadQueue");
+    addToDownloadQueue(item) {
+        this.checkDisposed("Device.addToDownloadQueue");
         // Check if item already exists in queue
-        const existingIndex = this._audioDownloadQueueView.values.findIndex(item => item.text === text);
+        const existingIndex = this._downloadQueueView.values.findIndex(queueItem => {
+            if (queueItem.type === 'audio' && item.type === 'audio') {
+                return queueItem.text === item.text;
+            }
+            else if (queueItem.type === 'image' && item.type === 'image') {
+                return queueItem.image_id === item.image_id;
+            }
+            return false;
+        });
         if (existingIndex !== -1) {
-            console.log(`Audio download already queued for: ${text}`);
+            console.log(`Download already queued for: ${item.type}`, item);
             return;
         }
+        this._downloadQueueView.push(item);
+        console.log(`Added to download queue: ${item.type}`, item);
+    }
+    removeFromDownloadQueue(predicate) {
+        this.checkDisposed("Device.removeFromDownloadQueue");
+        const itemIndex = this._downloadQueueView.values.findIndex(predicate);
+        if (itemIndex !== -1) {
+            this._downloadQueueView.removeAt(itemIndex);
+            console.log(`Removed from download queue at index ${itemIndex}`);
+        }
+    }
+    updateDownloadQueueItem(predicate, updates) {
+        this.checkDisposed("Device.updateDownloadQueueItem");
+        const itemIndex = this._downloadQueueView.values.findIndex(predicate);
+        if (itemIndex !== -1) {
+            for (const [key, value] of Object.entries(updates)) {
+                this._downloadQueueView.setObjectValueAtIndex(itemIndex, key, value);
+            }
+            console.log(`Updated download queue item at index ${itemIndex}`, updates);
+        }
+    }
+    // Convenience methods for audio downloads (backward compatibility)
+    addAudioToDownloadQueue(text) {
         const now = shaxpir_common_1.ClockService.getClock().utc();
-        const newItem = {
+        this.addToDownloadQueue({
+            type: 'audio',
             text,
             added_at: now,
             retry_count: 0
-        };
-        this._audioDownloadQueueView.push(newItem);
-        console.log(`Added to audio download queue: ${text}`);
-    }
-    removeFromAudioDownloadQueue(text) {
-        this.checkDisposed("Device.removeFromAudioDownloadQueue");
-        // Find the item index
-        const itemIndex = this._audioDownloadQueueView.values.findIndex(item => item.text === text);
+        });
+    }
+    removeAudioFromDownloadQueue(text) {
+        this.removeFromDownloadQueue(item => item.type === 'audio' && item.text === text);
+    }
+    // Upload Queue Methods
+    get uploadQueue() {
+        this.checkDisposed("Device.uploadQueue");
+        return this._uploadQueueView.values;
+    }
+    get uploadQueueLength() {
+        this.checkDisposed("Device.uploadQueueLength");
+        return this._uploadQueueView.length;
+    }
+    addToUploadQueue(item) {
+        this.checkDisposed("Device.addToUploadQueue");
+        // Check if item already exists in queue
+        const existingIndex = this._uploadQueueView.values.findIndex(queueItem => {
+            if (queueItem.type === 'image' && item.type === 'image') {
+                return queueItem.image_id === item.image_id;
+            }
+            return false;
+        });
+        if (existingIndex !== -1) {
+            console.log(`Upload already queued for: ${item.type}`, item);
+            return;
+        }
+        this._uploadQueueView.push(item);
+        console.log(`Added to upload queue: ${item.type}`, item);
+    }
+    removeFromUploadQueue(predicate) {
+        this.checkDisposed("Device.removeFromUploadQueue");
+        const itemIndex = this._uploadQueueView.values.findIndex(predicate);
         if (itemIndex !== -1) {
-            this._audioDownloadQueueView.removeAt(itemIndex);
-            console.log(`Removed from audio download queue: ${text}`);
+            this._uploadQueueView.removeAt(itemIndex);
+            console.log(`Removed from upload queue at index ${itemIndex}`);
         }
     }
-    updateAudioDownloadQueueItem(text, updates) {
-        this.checkDisposed("Device.updateAudioDownloadQueueItem");
-        const itemIndex = this._audioDownloadQueueView.values.findIndex(item => item.text === text);
+    updateUploadQueueItem(predicate, updates) {
+        this.checkDisposed("Device.updateUploadQueueItem");
+        const itemIndex = this._uploadQueueView.values.findIndex(predicate);
         if (itemIndex !== -1) {
-            // Update each field in the updates object
             for (const [key, value] of Object.entries(updates)) {
-                this._audioDownloadQueueView.setObjectValueAtIndex(itemIndex, key, value);
+                this._uploadQueueView.setObjectValueAtIndex(itemIndex, key, value);
             }
-            console.log(`Updated audio download queue item: ${text}`, updates);
+            console.log(`Updated upload queue item at index ${itemIndex}`, updates);
         }
     }
+    // Convenience methods for image uploads
+    addImageToUploadQueue(imageId) {
+        const now = shaxpir_common_1.ClockService.getClock().utc();
+        this.addToUploadQueue({
+            type: 'image',
+            image_id: imageId,
+            added_at: now,
+            retry_count: 0
+        });
+    }
+    removeImageFromUploadQueue(imageId) {
+        this.removeFromUploadQueue(item => item.type === 'image' && item.image_id === imageId);
+    }
 }
 exports.Device = Device;

package/dist/models/Image.d.ts

@@ -0,0 +1,31 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../repo';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+export interface ImageCropping extends ImageDimensions {
+    offset_top: number;
+    offset_left: number;
+}
+export interface ImagePayload extends ImageDimensions {
+    extension: string;
+    bytes: number;
+}
+export interface ImageBody extends ContentBody {
+    meta: ContentMeta;
+    payload: ImagePayload;
+}
+export declare class Image extends Content {
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): ImagePayload;
+    static create(userId: ContentId, imageId: ContentId, payload: ImagePayload): Image;
+    get bytes(): number;
+    get width(): number;
+    get height(): number;
+    get extension(): string;
+    get mimeType(): string;
+    scaleToFit(boxSize: number, cropping: ImageCropping): ImageCropping;
+    static makeDefaultCropping(image: Image): ImageCropping;
+}

package/dist/models/{Media.js → Image.js}

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Media = void 0;
+exports.Image = void 0;
 const shaxpir_common_1 = require("@shaxpir/shaxpir-common");
 const repo_1 = require("../repo");
 const Content_1 = require("./Content");
 const ContentKind_1 = require("./ContentKind");
-class Media extends Content_1.Content {
+class Image extends Content_1.Content {
     constructor(doc, shouldAcquire, shareSync) {
         super(doc, shouldAcquire, shareSync);
     }
     get payload() {
-        this.checkDisposed("Media.payload");
+        this.checkDisposed("Image.payload");
         return this.doc.data.payload;
     }
-    static create(userId, mediaId, payload) {
+    static create(userId, imageId, payload) {
         const now = shaxpir_common_1.ClockService.getClock().now();
         return repo_1.ShareSyncFactory.get().createContent({
             meta: {
-                ref: mediaId,
-                kind: ContentKind_1.ContentKind.MEDIA,
-                id: mediaId,
+                ref: imageId,
+                kind: ContentKind_1.ContentKind.IMAGE,
+                id: imageId,
                 owner: userId,
                 created_at: now,
                 updated_at: now
@@ -28,23 +28,23 @@ class Media extends Content_1.Content {
         });
     }
     get bytes() {
-        this.checkDisposed("Media.bytes");
+        this.checkDisposed("Image.bytes");
         return this.payload.bytes;
     }
     get width() {
-        this.checkDisposed("Media.width");
+        this.checkDisposed("Image.width");
         return this.payload.width;
     }
     get height() {
-        this.checkDisposed("Media.height");
+        this.checkDisposed("Image.height");
         return this.payload.height;
     }
     get extension() {
-        this.checkDisposed("Media.extension");
+        this.checkDisposed("Image.extension");
         return this.payload.extension;
     }
-    get mediaType() {
-        this.checkDisposed("Media.mediaType");
+    get mimeType() {
+        this.checkDisposed("Image.mimeType");
         const extension = this.extension;
         if (extension === "jpg" || extension === "jpeg") {
             return "image/jpeg";
@@ -64,7 +64,7 @@ class Media extends Content_1.Content {
         return "image/" + extension;
     }
     scaleToFit(boxSize, cropping) {
-        this.checkDisposed("Media.scaleToFit");
+        this.checkDisposed("Image.scaleToFit");
         const zoom = boxSize / cropping.width;
         const scaledWidth = Math.floor(this.width * zoom);
         const scaledHeight = Math.floor(this.height * zoom);
@@ -77,9 +77,9 @@ class Media extends Content_1.Content {
             "height": scaledHeight
         };
     }
-    static makeDefaultCropping(media) {
-        const width = media.width;
-        const height = media.height;
+    static makeDefaultCropping(image) {
+        const width = image.width;
+        const height = image.height;
         const isLandscapeOrSquare = width >= height;
         const isPortraitOrSquare = height >= width;
         const croppingOffsetTop = isLandscapeOrSquare ? 0 : Math.floor((height - width) / 2);
@@ -94,4 +94,4 @@ class Media extends Content_1.Content {
         };
     }
 }
-exports.Media = Media;
+exports.Image = Image;

package/dist/models/Manifest.d.ts

@@ -22,7 +22,7 @@ export interface ManifestEntry {
 export interface ManifestPayload {
     billing: any;
     device: any;
-    media: any;
+    image: any;
     metric: any;
     profile: any;
     progress: any;

package/dist/models/Manifest.js

@@ -28,7 +28,7 @@ class Manifest extends Model_1.Model {
             payload: {
                 billing: {},
                 device: {},
-                media: {},
+                image: {},
                 metric: {},
                 profile: {},
                 progress: {},

package/dist/models/Profile.d.ts

@@ -1,12 +1,12 @@
 import { Doc } from '@shaxpir/sharedb/lib/client';
 import { ShareSync } from '../repo';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
-import { MediaCropping } from './Media';
+import { ImageCropping } from './Image';
 export interface ProfilePayload {
     username: string;
     full_name: string;
-    avatar_media_ref: ContentId;
-    avatar_cropping: MediaCropping;
+    avatar_image_ref: ContentId;
+    avatar_cropping: ImageCropping;
 }
 export interface ProfileBody extends ContentBody {
     meta: ContentMeta;
@@ -21,9 +21,9 @@ export declare class Profile extends Content {
     setUsername(value: string): void;
     get fullName(): string;
     setFullName(value: string): void;
-    get avatarMediaRef(): ContentId;
-    setAvatarMediaRef(value: ContentId): void;
-    get avatarCropping(): MediaCropping;
-    setAvatarCropping(value: MediaCropping): void;
+    get avatarImageRef(): ContentId;
+    setAvatarImageRef(value: ContentId): void;
+    get avatarCropping(): ImageCropping;
+    setAvatarCropping(value: ImageCropping): void;
     static findByUsername(username: string): Promise<Profile[]>;
 }

package/dist/models/Profile.js

@@ -25,7 +25,7 @@ class Profile extends Content_1.Content {
             payload: {
                 username: null,
                 full_name: '',
-                avatar_media_ref: null,
+                avatar_image_ref: null,
                 avatar_cropping: null
             }
         });
@@ -61,15 +61,15 @@ class Profile extends Content_1.Content {
             batch.commit();
         }
     }
-    get avatarMediaRef() {
-        this.checkDisposed("Profile.avatarMediaRef");
-        return this.payload.avatar_media_ref;
+    get avatarImageRef() {
+        this.checkDisposed("Profile.avatarImageRef");
+        return this.payload.avatar_image_ref;
     }
-    setAvatarMediaRef(value) {
-        this.checkDisposed("Profile.setAvatarMediaRef");
-        if (this.avatarMediaRef !== value) {
+    setAvatarImageRef(value) {
+        this.checkDisposed("Profile.setAvatarImageRef");
+        if (this.avatarImageRef !== value) {
             const batch = new Operation_1.BatchOperation(this);
-            batch.setPathValue(['payload', 'avatar_media_ref'], value);
+            batch.setPathValue(['payload', 'avatar_image_ref'], value);
             batch.commit();
         }
     }

package/dist/models/index.d.ts

@@ -10,7 +10,7 @@ export * from './Flag';
 export * from './GeoLocation';
 export * from './Hanzi';
 export * from './Manifest';
-export * from './Media';
+export * from './Image';
 export * from './Metric';
 export * from './Model';
 export * from './Operation';

package/dist/models/index.js

@@ -27,7 +27,7 @@ __exportStar(require("./Flag"), exports);
 __exportStar(require("./GeoLocation"), exports);
 __exportStar(require("./Hanzi"), exports);
 __exportStar(require("./Manifest"), exports);
-__exportStar(require("./Media"), exports);
+__exportStar(require("./Image"), exports);
 __exportStar(require("./Metric"), exports);
 __exportStar(require("./Model"), exports);
 __exportStar(require("./Operation"), exports);

package/dist/repo/ShareSync.js

@@ -419,8 +419,8 @@ class ShareSync {
         else if (kind === ContentKind_1.ContentKind.METRIC) {
             return new models_1.Metric(doc, shouldAcquire, shareSync);
         }
-        else if (kind === ContentKind_1.ContentKind.MEDIA) {
-            return new models_1.Media(doc, shouldAcquire, shareSync);
+        else if (kind === ContentKind_1.ContentKind.IMAGE) {
+            return new models_1.Image(doc, shouldAcquire, shareSync);
         }
         else if (kind === ContentKind_1.ContentKind.PROFILE) {
             return new models_1.Profile(doc, shouldAcquire, shareSync);

package/package.json

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

package/dist/models/Media.d.ts

@@ -1,31 +0,0 @@
-import { Doc } from '@shaxpir/sharedb/lib/client';
-import { ShareSync } from '../repo';
-import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
-export interface MediaDimensions {
-    width: number;
-    height: number;
-}
-export interface MediaCropping extends MediaDimensions {
-    offset_top: number;
-    offset_left: number;
-}
-export interface MediaPayload extends MediaDimensions {
-    extension: string;
-    bytes: number;
-}
-export interface MediaBody extends ContentBody {
-    meta: ContentMeta;
-    payload: MediaPayload;
-}
-export declare class Media extends Content {
-    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
-    get payload(): MediaPayload;
-    static create(userId: ContentId, mediaId: ContentId, payload: MediaPayload): Media;
-    get bytes(): number;
-    get width(): number;
-    get height(): number;
-    get extension(): string;
-    get mediaType(): string;
-    scaleToFit(boxSize: number, cropping: MediaCropping): MediaCropping;
-    static makeDefaultCropping(media: Media): MediaCropping;
-}