@shaxpir/duiduidui-models 1.9.31 → 1.10.1

package/dist/models/Condition.d.ts

@@ -1,4 +1,5 @@
 import { CompactDateTime } from "@shaxpir/shaxpir-common";
+import { RecordType } from "./RecordType";
 export interface BaseCondition {
     type: string;
 }
@@ -46,7 +47,15 @@ export interface ComponentCondition extends BaseCondition {
     components: string[];
     mode: 'any' | 'all';
 }
-export type AnyCondition = TagCondition | GradeCondition | ThetaCondition | TemporalCondition | CountCondition | StarredCondition | DifficultyCondition | HasTermCondition | ComponentCondition;
+export interface RecordTypeCondition extends BaseCondition {
+    type: 'record_type';
+    recordType: RecordType;
+}
+export interface ExcludeRecordTypeCondition extends BaseCondition {
+    type: 'exclude_record_type';
+    recordType: RecordType;
+}
+export type AnyCondition = TagCondition | GradeCondition | ThetaCondition | TemporalCondition | CountCondition | StarredCondition | DifficultyCondition | HasTermCondition | ComponentCondition | RecordTypeCondition | ExcludeRecordTypeCondition;
 export interface Conditions {
     all?: AnyCondition[];
     any?: AnyCondition[];
@@ -87,6 +96,15 @@ export declare const Condition: {
     hasComponent: (component: string) => ComponentCondition;
     hasAnyComponent: (components: string[]) => ComponentCondition;
     hasAllComponents: (components: string[]) => ComponentCondition;
+    recordType: (recordType: RecordType) => RecordTypeCondition;
+    excludeRecordType: (recordType: RecordType) => ExcludeRecordTypeCondition;
+    strokes: () => RecordTypeCondition;
+    radicals: () => RecordTypeCondition;
+    characters: () => RecordTypeCondition;
+    words: () => RecordTypeCondition;
+    phrases: () => RecordTypeCondition;
+    patterns: () => RecordTypeCondition;
+    sentences: () => RecordTypeCondition;
     /**
      * Check if starred condition is required (in 'all' section)
      */
@@ -128,6 +146,31 @@ export declare const Condition: {
      * Returns an array of error messages, empty if valid
      */
     validate: (conditions?: Conditions) => string[];
+    /**
+     * Extract included record types from conditions.
+     * Returns null if no record type conditions are specified (meaning all types are included).
+     * Returns an array of included types if record_type conditions are in 'all' or 'any'.
+     */
+    getIncludedRecordTypes: (conditions?: Conditions) => RecordType[] | null;
+    /**
+     * Extract excluded record types from conditions.
+     * Returns an array of types to exclude based on exclude_record_type conditions in 'all'
+     * or record_type conditions in 'none'.
+     */
+    getExcludedRecordTypes: (conditions?: Conditions) => RecordType[];
+    /**
+     * Check if a specific record type is required (in 'all' section)
+     */
+    requiresRecordType: (conditions: Conditions | undefined, recordType: RecordType) => boolean;
+    /**
+     * Check if a specific record type is excluded
+     */
+    excludesRecordType: (conditions: Conditions | undefined, recordType: RecordType) => boolean;
+    /**
+     * Get the effective record types to query based on conditions.
+     * Returns the set of types that should be included in a query.
+     */
+    getEffectiveRecordTypes: (conditions?: Conditions) => RecordType[];
     hasStarredInAll: (filters?: ConditionFilters) => boolean;
     hasStarredInAny: (filters?: ConditionFilters) => boolean;
     hasStarredInNone: (filters?: ConditionFilters) => boolean;

package/dist/models/Condition.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Condition = void 0;
+const RecordType_1 = require("./RecordType");
 // Factory functions for creating conditions
 exports.Condition = {
     // Tag conditions
@@ -45,6 +46,17 @@ exports.Condition = {
     hasComponent: (component) => ({ type: 'component', components: [component], mode: 'any' }),
     hasAnyComponent: (components) => ({ type: 'component', components, mode: 'any' }),
     hasAllComponents: (components) => ({ type: 'component', components, mode: 'all' }),
+    // Record type conditions
+    recordType: (recordType) => ({ type: 'record_type', recordType }),
+    excludeRecordType: (recordType) => ({ type: 'exclude_record_type', recordType }),
+    // Convenience methods for common record types
+    strokes: () => ({ type: 'record_type', recordType: 'stroke' }),
+    radicals: () => ({ type: 'record_type', recordType: 'radical' }),
+    characters: () => ({ type: 'record_type', recordType: 'character' }),
+    words: () => ({ type: 'record_type', recordType: 'word' }),
+    phrases: () => ({ type: 'record_type', recordType: 'phrase' }),
+    patterns: () => ({ type: 'record_type', recordType: 'pattern' }),
+    sentences: () => ({ type: 'record_type', recordType: 'sentence' }),
     // Helper methods to check if conditions are present in filters
     /**
      * Check if starred condition is required (in 'all' section)
@@ -168,8 +180,118 @@ exports.Condition = {
                 errors.push(`Min difficulty (${min}) must be less than max difficulty (${max})`);
             }
         }
+        // Check for contradictory record type conditions
+        const allRecordTypes = conditions.all
+            ?.filter(c => c.type === 'record_type')
+            .map(c => c.recordType) || [];
+        const noneRecordTypes = conditions.none
+            ?.filter(c => c.type === 'record_type')
+            .map(c => c.recordType) || [];
+        const excludedRecordTypes = conditions.all
+            ?.filter(c => c.type === 'exclude_record_type')
+            .map(c => c.recordType) || [];
+        // Check for multiple required record types (an item can only have one record type)
+        if (allRecordTypes.length > 1) {
+            errors.push(`Cannot require multiple record types: ${allRecordTypes.join(', ')} - an item can only have one record type`);
+        }
+        // Check for record_type in 'all' conflicting with same type in 'none'
+        allRecordTypes.forEach(rt => {
+            if (noneRecordTypes.includes(rt)) {
+                errors.push(`Record type "${rt}" cannot be both required and excluded`);
+            }
+        });
+        // Check for record_type in 'all' conflicting with exclude_record_type for same type
+        allRecordTypes.forEach(rt => {
+            if (excludedRecordTypes.includes(rt)) {
+                errors.push(`Record type "${rt}" cannot be both required (record_type) and excluded (exclude_record_type)`);
+            }
+        });
+        // Check if all record types would be excluded (empty result set)
+        const effectiveTypes = exports.Condition.getEffectiveRecordTypes(conditions);
+        if (effectiveTypes.length === 0) {
+            errors.push('All record types are excluded - query would return no results');
+        }
         return errors;
     },
+    /**
+     * Extract included record types from conditions.
+     * Returns null if no record type conditions are specified (meaning all types are included).
+     * Returns an array of included types if record_type conditions are in 'all' or 'any'.
+     */
+    getIncludedRecordTypes: (conditions) => {
+        if (!conditions)
+            return null;
+        // Check 'all' section for record_type conditions
+        const allRecordTypes = conditions.all
+            ?.filter(c => c.type === 'record_type')
+            .map(c => c.recordType) || [];
+        // Check 'any' section for record_type conditions
+        const anyRecordTypes = conditions.any
+            ?.filter(c => c.type === 'record_type')
+            .map(c => c.recordType) || [];
+        // If there are record_type conditions in 'all', those are required
+        if (allRecordTypes.length > 0) {
+            return allRecordTypes;
+        }
+        // If there are record_type conditions in 'any', those are the allowed types
+        if (anyRecordTypes.length > 0) {
+            return anyRecordTypes;
+        }
+        // No record type constraints
+        return null;
+    },
+    /**
+     * Extract excluded record types from conditions.
+     * Returns an array of types to exclude based on exclude_record_type conditions in 'all'
+     * or record_type conditions in 'none'.
+     */
+    getExcludedRecordTypes: (conditions) => {
+        if (!conditions)
+            return [];
+        const excluded = [];
+        // Check 'all' section for exclude_record_type conditions
+        const allExclusions = conditions.all
+            ?.filter(c => c.type === 'exclude_record_type')
+            .map(c => c.recordType) || [];
+        excluded.push(...allExclusions);
+        // Check 'none' section for record_type conditions (these types should be excluded)
+        const noneRecordTypes = conditions.none
+            ?.filter(c => c.type === 'record_type')
+            .map(c => c.recordType) || [];
+        excluded.push(...noneRecordTypes);
+        return [...new Set(excluded)]; // Deduplicate
+    },
+    /**
+     * Check if a specific record type is required (in 'all' section)
+     */
+    requiresRecordType: (conditions, recordType) => {
+        return !!(conditions?.all?.some(c => c.type === 'record_type' && c.recordType === recordType));
+    },
+    /**
+     * Check if a specific record type is excluded
+     */
+    excludesRecordType: (conditions, recordType) => {
+        // Check exclude_record_type in 'all'
+        const hasExcludeCondition = conditions?.all?.some(c => c.type === 'exclude_record_type' && c.recordType === recordType);
+        // Check record_type in 'none'
+        const hasNoneCondition = conditions?.none?.some(c => c.type === 'record_type' && c.recordType === recordType);
+        return !!(hasExcludeCondition || hasNoneCondition);
+    },
+    /**
+     * Get the effective record types to query based on conditions.
+     * Returns the set of types that should be included in a query.
+     */
+    getEffectiveRecordTypes: (conditions) => {
+        const included = exports.Condition.getIncludedRecordTypes(conditions);
+        const excluded = exports.Condition.getExcludedRecordTypes(conditions);
+        // Start with included types, or all types if none specified
+        let types = included ?? [...RecordType_1.RECORD_TYPES];
+        // Remove excluded types
+        if (excluded.length > 0) {
+            types = types.filter(t => !excluded.includes(t));
+        }
+        return types;
+    },
     // Backward compatibility aliases (deprecated - use requiresStarred/allowsStarred/excludesStarred instead)
     hasStarredInAll: (filters) => exports.Condition.requiresStarred(filters),
     hasStarredInAny: (filters) => exports.Condition.allowsStarred(filters),

package/dist/models/Phrase.d.ts

@@ -1,5 +1,6 @@
 import { CompactDateTime } from "@shaxpir/shaxpir-common";
 import { ContentId } from "./Content";
+import { RecordType } from "./RecordType";
 import { ReviewLike } from "./Review";
 export interface PhraseExample {
     id: number;
@@ -8,6 +9,7 @@ export interface PhraseExample {
     translation: string;
     difficulty: number;
     sense_rank: number;
+    type?: RecordType;
 }
 export interface Phrase {
     text: string;
@@ -26,10 +28,12 @@ export interface Phrase {
 }
 export interface BuiltInPhrase extends Phrase {
     id: number;
+    type: RecordType;
 }
 export interface AnnotatedPhrase extends Phrase {
     id: string;
     phrase_id?: number;
+    type?: RecordType | null;
     content_id?: ContentId;
     starred_at: CompactDateTime | null;
     alpha: number | null;

package/dist/models/RecordType.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Record types in the dictionary database.
+ *
+ * Each record type has its own table and a well-known ID range.
+ * This allows determining record type from ID alone.
+ */
+export type RecordType = 'stroke' | 'radical' | 'character' | 'word' | 'phrase' | 'pattern' | 'sentence';
+/**
+ * Ordered array of all record types.
+ * Order reflects linguistic hierarchy from smallest to largest units.
+ */
+export declare const RECORD_TYPES: RecordType[];
+/**
+ * ID ranges for each record type.
+ * Records are assigned IDs in ascending difficulty order within their type's range.
+ */
+export declare const ID_RANGES: Record<RecordType, {
+    min: number;
+    max: number;
+}>;
+/**
+ * Determine the record type from an ID based on ID ranges.
+ *
+ * @param id - The record ID
+ * @returns The record type, or null if ID is outside all known ranges
+ */
+export declare function getRecordTypeFromId(id: number): RecordType | null;
+/**
+ * Check if an ID belongs to a specific record type.
+ *
+ * @param id - The record ID
+ * @param type - The record type to check
+ * @returns true if the ID is within the range for the given type
+ */
+export declare function isRecordType(id: number, type: RecordType): boolean;
+/**
+ * Get the table name for a record type.
+ * Table names match record type names exactly.
+ *
+ * @param type - The record type
+ * @returns The table name (same as type)
+ */
+export declare function getTableForRecordType(type: RecordType): string;
+/**
+ * Get the table name for a record ID.
+ *
+ * @param id - The record ID
+ * @returns The table name, or null if ID is outside all known ranges
+ */
+export declare function getTableForId(id: number): string | null;

package/dist/models/RecordType.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ID_RANGES = exports.RECORD_TYPES = void 0;
+exports.getRecordTypeFromId = getRecordTypeFromId;
+exports.isRecordType = isRecordType;
+exports.getTableForRecordType = getTableForRecordType;
+exports.getTableForId = getTableForId;
+/**
+ * Ordered array of all record types.
+ * Order reflects linguistic hierarchy from smallest to largest units.
+ */
+exports.RECORD_TYPES = [
+    'stroke',
+    'radical',
+    'character',
+    'word',
+    'phrase',
+    'pattern',
+    'sentence'
+];
+/**
+ * ID ranges for each record type.
+ * Records are assigned IDs in ascending difficulty order within their type's range.
+ */
+exports.ID_RANGES = {
+    stroke: { min: 0, max: 999 },
+    radical: { min: 1000, max: 9999 },
+    character: { min: 10000, max: 49999 },
+    word: { min: 50000, max: 149999 },
+    phrase: { min: 150000, max: 239999 },
+    pattern: { min: 240000, max: 249999 },
+    sentence: { min: 250000, max: 999999 }
+};
+/**
+ * Determine the record type from an ID based on ID ranges.
+ *
+ * @param id - The record ID
+ * @returns The record type, or null if ID is outside all known ranges
+ */
+function getRecordTypeFromId(id) {
+    for (const type of exports.RECORD_TYPES) {
+        const range = exports.ID_RANGES[type];
+        if (id >= range.min && id <= range.max) {
+            return type;
+        }
+    }
+    return null;
+}
+/**
+ * Check if an ID belongs to a specific record type.
+ *
+ * @param id - The record ID
+ * @param type - The record type to check
+ * @returns true if the ID is within the range for the given type
+ */
+function isRecordType(id, type) {
+    const range = exports.ID_RANGES[type];
+    return id >= range.min && id <= range.max;
+}
+/**
+ * Get the table name for a record type.
+ * Table names match record type names exactly.
+ *
+ * @param type - The record type
+ * @returns The table name (same as type)
+ */
+function getTableForRecordType(type) {
+    return type;
+}
+/**
+ * Get the table name for a record ID.
+ *
+ * @param id - The record ID
+ * @returns The table name, or null if ID is outside all known ranges
+ */
+function getTableForId(id) {
+    const type = getRecordTypeFromId(id);
+    return type;
+}

package/dist/models/SearchState.d.ts

@@ -12,6 +12,7 @@ import { Conditions } from './Condition';
 export interface SearchState {
     query?: string;
     senseRank?: number;
+    phraseId?: number;
     conditions?: Conditions;
 }
 /**

package/dist/models/SearchState.js

@@ -35,6 +35,9 @@ function areSearchStatesEqual(a, b) {
     // Compare senseRank
     if (a.senseRank !== b.senseRank)
         return false;
+    // Compare phraseId
+    if (a.phraseId !== b.phraseId)
+        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;

package/dist/models/Term.d.ts

@@ -4,12 +4,14 @@ import { ShareSync } from '../repo';
 import { BayesianScore } from './BayesianScore';
 import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
 import { BuiltInPhrase, Phrase, PhraseExample } from './Phrase';
+import { RecordType } from './RecordType';
 import { ImpliedReview, ReviewLike } from "./Review";
 export interface TermSummary {
     text: string;
     sense_rank: number;
     difficulty: number;
     phrase_id: number | null;
+    type: RecordType;
     starred_at: CompactDateTime | null;
     alpha: number;
     beta: number;
@@ -25,6 +27,7 @@ export interface TermPayload extends BayesianScore {
     sense_rank: number;
     difficulty: number;
     phrase_id: number | null;
+    type: RecordType;
     starred_at: CompactDateTime | null;
     alpha: number;
     beta: number;
@@ -57,13 +60,14 @@ export declare class Term extends Content {
     private _impliedReviewsView;
     private _userTagsView;
     constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
-    static forUserPhrase(userId: ContentId, text: string, senseRank: number, difficulty: number, phraseId?: number): Term;
-    static forUserPhrase(userId: ContentId, phrase: Phrase): Term;
+    static forUserPhrase(userId: ContentId, text: string, senseRank: number, difficulty: number, type: RecordType, phraseId?: number): Term;
+    static forUserPhrase(userId: ContentId, phrase: Phrase, type: RecordType): Term;
     static forBuiltinPhrase(userId: ContentId, phrase: BuiltInPhrase): Term;
     get payload(): TermPayload;
     get text(): string;
     get senseRank(): number;
     get difficulty(): number;
+    get type(): RecordType;
     get alpha(): number;
     get beta(): number;
     get theta(): number;

package/dist/models/Term.js

@@ -8,6 +8,7 @@ const BayesianScore_1 = require("./BayesianScore");
 const Content_1 = require("./Content");
 const ContentKind_1 = require("./ContentKind");
 const Operation_1 = require("./Operation");
+const RecordType_1 = require("./RecordType");
 class Term extends Content_1.Content {
     static makeTermId(userId, text, senseRank) {
         return shaxpir_common_1.CachingHasher.makeMd5Base62Hash(`${ContentKind_1.ContentKind.TERM}-${userId}-${text}-${senseRank}`);
@@ -18,11 +19,18 @@ class Term extends Content_1.Content {
         this._impliedReviewsView = new ArrayView_1.ArrayView(this, ['payload', 'implied_reviews']);
         this._userTagsView = new ArrayView_1.ArrayView(this, ['payload', 'user_tags']);
     }
-    static forUserPhrase(userId, textOrPhrase, senseRank, difficulty, phraseId) {
+    static forUserPhrase(userId, textOrPhrase, senseRankOrType, difficultyOrNothing, typeOrPhraseId, phraseId) {
         const now = shaxpir_common_1.ClockService.getClock().now();
         // Handle overloaded parameters
         let phrase;
+        let recordType;
+        let resolvedPhraseId;
         if (typeof textOrPhrase === 'string') {
+            // First overload: (userId, text, senseRank, difficulty, type, phraseId?)
+            const senseRank = senseRankOrType;
+            const difficulty = difficultyOrNothing;
+            recordType = typeOrPhraseId;
+            resolvedPhraseId = phraseId;
             // Create a minimal Phrase object from individual parameters
             phrase = {
                 text: textOrPhrase,
@@ -40,9 +48,12 @@ class Term extends Content_1.Content {
             };
         }
         else {
+            // Second overload: (userId, phrase, type)
             phrase = textOrPhrase;
+            recordType = senseRankOrType;
+            resolvedPhraseId = undefined;
         }
-        const termId = Term.makeTermId(userId, phrase.text, senseRank);
+        const termId = Term.makeTermId(userId, phrase.text, phrase.sense_rank);
         return repo_1.ShareSyncFactory.get().createContent({
             meta: {
                 ref: termId,
@@ -53,7 +64,8 @@ class Term extends Content_1.Content {
                 updated_at: now
             },
             payload: {
-                phrase_id: (typeof textOrPhrase === 'string' && phraseId) ? phraseId : null,
+                phrase_id: resolvedPhraseId ?? null,
+                type: recordType,
                 text: phrase.text,
                 sense_rank: phrase.sense_rank,
                 hanzi_count: phrase.hanzi_count,
@@ -97,6 +109,7 @@ class Term extends Content_1.Content {
                 sense_rank: phrase.sense_rank,
                 difficulty: phrase.difficulty,
                 phrase_id: phrase.id,
+                type: phrase.type ?? (0, RecordType_1.getRecordTypeFromId)(phrase.id), // Use phrase.type if available, else derive from ID
                 starred_at: null,
                 user_tags: [],
                 user_tag_count: 0,
@@ -128,6 +141,10 @@ class Term extends Content_1.Content {
         this.checkDisposed("Term.difficulty");
         return this.payload.difficulty;
     }
+    get type() {
+        this.checkDisposed("Term.type");
+        return this.payload.type;
+    }
     get alpha() {
         this.checkDisposed("Term.alpha");
         return this.payload.alpha;

package/dist/models/index.d.ts

@@ -20,6 +20,7 @@ export * from './Permissions';
 export * from './Phrase';
 export * from './Profile';
 export * from './Progress';
+export * from './RecordType';
 export * from './Review';
 export * from './SearchState';
 export * from './Session';

package/dist/models/index.js

@@ -37,6 +37,7 @@ __exportStar(require("./Permissions"), exports);
 __exportStar(require("./Phrase"), exports);
 __exportStar(require("./Profile"), exports);
 __exportStar(require("./Progress"), exports);
+__exportStar(require("./RecordType"), exports);
 __exportStar(require("./Review"), exports);
 __exportStar(require("./SearchState"), exports);
 __exportStar(require("./Session"), exports);

package/dist/util/ConditionMatcher.d.ts

@@ -1,5 +1,6 @@
 import { CompactDateTime } from "@shaxpir/shaxpir-common";
 import { AnyCondition, Conditions } from '../models/Condition';
+import { RecordType } from '../models/RecordType';
 /**
  * Interface for objects that can be matched against Conditions.
  * This is the minimum set of fields needed for condition matching.
@@ -18,6 +19,8 @@ export interface ConditionMatchable {
     updated_at?: CompactDateTime;
     review_count?: number;
     implied_review_count?: number;
+    type?: RecordType | null;
+    phrase_id?: number;
 }
 /**
  * Utility for checking if objects match Conditions.

package/dist/util/ConditionMatcher.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionMatcher = void 0;
+const RecordType_1 = require("../models/RecordType");
 /**
  * Utility for checking if objects match Conditions.
  *
@@ -118,6 +119,26 @@ exports.ConditionMatcher = {
                 // suitable for in-memory filtering. Return true (don't filter out).
                 return true;
             }
+            case 'record_type': {
+                const rtCond = condition;
+                // Try to get type directly, or derive from phrase_id
+                const itemType = item.type ?? (item.phrase_id !== undefined ? (0, RecordType_1.getRecordTypeFromId)(item.phrase_id) : null);
+                if (itemType === null) {
+                    // Cannot determine type - user-created term without type, return true (don't filter out)
+                    return true;
+                }
+                return itemType === rtCond.recordType;
+            }
+            case 'exclude_record_type': {
+                const ertCond = condition;
+                // Try to get type directly, or derive from phrase_id
+                const itemType = item.type ?? (item.phrase_id !== undefined ? (0, RecordType_1.getRecordTypeFromId)(item.phrase_id) : null);
+                if (itemType === null) {
+                    // Cannot determine type - user-created term without type, return true (don't filter out)
+                    return true;
+                }
+                return itemType !== ertCond.recordType;
+            }
             default:
                 // For unsupported conditions, default to true (don't filter out)
                 return true;

package/package.json

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