@shaxpir/duiduidui-models 1.5.13 → 1.5.15

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/Phrase.d.ts

@@ -32,10 +32,10 @@ export interface AnnotatedPhrase extends Phrase {
     phrase_id?: number;
     content_id?: ContentId;
     starred_at: CompactDateTime | null;
-    alpha: number;
-    beta: number;
-    theta: number;
-    uncertainty: number;
+    alpha: number | null;
+    beta: number | null;
+    theta: number | null;
+    uncertainty: number | null;
     reviews: ReviewLike[];
     user_tags: string[];
 }

package/package.json

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