@shaxpir/duiduidui-models 1.9.25 → 1.9.26

package/dist/util/DifficultyRange.d.ts

@@ -0,0 +1,60 @@
+import { Conditions } from '../models/Condition';
+/**
+ * Represents a difficulty range with guaranteed min (defaults to 0).
+ * Used for intersecting pool difficulty ranges with Collection constraints.
+ */
+export interface DifficultyRange {
+    min: number;
+    max: number | undefined;
+}
+/**
+ * Extracts difficulty constraints from Conditions.
+ *
+ * Checks the 'all' section for difficulty conditions since that's where
+ * Collection-level constraints are placed (they must all be satisfied).
+ *
+ * Exploits the invariant that difficulty and skill level are always >= 0,
+ * so min defaults to 0 when not specified.
+ *
+ * @param conditions - The conditions to search
+ * @returns DifficultyRange if a difficulty condition is found, null otherwise
+ */
+export declare function extractDifficultyConstraints(conditions?: Conditions): DifficultyRange | null;
+/**
+ * Result of intersecting difficulty ranges.
+ */
+export interface DifficultyRangeIntersection {
+    /** The effective minimum difficulty to use */
+    min: number;
+    /** The effective maximum difficulty to use */
+    max: number;
+    /** True if a valid intersection was found, false if fell back to Collection range */
+    usedIntersection: boolean;
+    /** True if Collection had a difficulty constraint */
+    hadCollectionConstraint: boolean;
+}
+/**
+ * Calculates the intersection of a pool's difficulty range with Collection constraints.
+ *
+ * If no intersection exists (ranges are disjoint), returns the Collection's range
+ * since the Collection constraints take precedence over skill-based calculations.
+ *
+ * @param poolMin - The pool's calculated minimum difficulty
+ * @param poolMax - The pool's calculated maximum difficulty
+ * @param collectionRange - The Collection's difficulty constraints (if any)
+ * @returns The effective range to use for queries, plus metadata
+ */
+export declare function intersectDifficultyRanges(poolMin: number, poolMax: number, collectionRange: DifficultyRange | null): DifficultyRangeIntersection;
+/**
+ * Checks if a difficulty value falls within a range.
+ *
+ * Useful for in-memory filtering in strategies that don't use database queries
+ * (ReinforcementPoolStrategy, StalePoolStrategy, DecompositionPoolStrategy).
+ *
+ * Uses half-open interval semantics: min is inclusive (>=), max is exclusive (<).
+ *
+ * @param difficulty - The difficulty value to check
+ * @param range - The range to check against (null means no constraint)
+ * @returns true if difficulty is within range or no range specified
+ */
+export declare function isWithinDifficultyRange(difficulty: number, range: DifficultyRange | null): boolean;

package/dist/util/DifficultyRange.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDifficultyConstraints = extractDifficultyConstraints;
+exports.intersectDifficultyRanges = intersectDifficultyRanges;
+exports.isWithinDifficultyRange = isWithinDifficultyRange;
+/**
+ * Extracts difficulty constraints from Conditions.
+ *
+ * Checks the 'all' section for difficulty conditions since that's where
+ * Collection-level constraints are placed (they must all be satisfied).
+ *
+ * Exploits the invariant that difficulty and skill level are always >= 0,
+ * so min defaults to 0 when not specified.
+ *
+ * @param conditions - The conditions to search
+ * @returns DifficultyRange if a difficulty condition is found, null otherwise
+ */
+function extractDifficultyConstraints(conditions) {
+    if (!conditions?.all)
+        return null;
+    for (const condition of conditions.all) {
+        if (condition.type === 'difficulty') {
+            const diffCondition = condition;
+            return {
+                min: diffCondition.min ?? 0,
+                max: diffCondition.max
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Calculates the intersection of a pool's difficulty range with Collection constraints.
+ *
+ * If no intersection exists (ranges are disjoint), returns the Collection's range
+ * since the Collection constraints take precedence over skill-based calculations.
+ *
+ * @param poolMin - The pool's calculated minimum difficulty
+ * @param poolMax - The pool's calculated maximum difficulty
+ * @param collectionRange - The Collection's difficulty constraints (if any)
+ * @returns The effective range to use for queries, plus metadata
+ */
+function intersectDifficultyRanges(poolMin, poolMax, collectionRange) {
+    // No Collection constraint - use pool's range as-is
+    if (!collectionRange) {
+        return {
+            min: poolMin,
+            max: poolMax,
+            usedIntersection: true,
+            hadCollectionConstraint: false
+        };
+    }
+    // Calculate intersection
+    const intersectMin = Math.max(poolMin, collectionRange.min);
+    const intersectMax = collectionRange.max !== undefined
+        ? Math.min(poolMax, collectionRange.max)
+        : poolMax; // No upper bound on Collection, use pool's max
+    // Check if intersection is valid (non-empty range)
+    if (intersectMin < intersectMax) {
+        return {
+            min: intersectMin,
+            max: intersectMax,
+            usedIntersection: true,
+            hadCollectionConstraint: true
+        };
+    }
+    // No valid intersection - fall back to Collection's range
+    return {
+        min: collectionRange.min,
+        max: collectionRange.max ?? poolMax, // Use pool max if Collection has no upper bound
+        usedIntersection: false,
+        hadCollectionConstraint: true
+    };
+}
+/**
+ * Checks if a difficulty value falls within a range.
+ *
+ * Useful for in-memory filtering in strategies that don't use database queries
+ * (ReinforcementPoolStrategy, StalePoolStrategy, DecompositionPoolStrategy).
+ *
+ * Uses half-open interval semantics: min is inclusive (>=), max is exclusive (<).
+ *
+ * @param difficulty - The difficulty value to check
+ * @param range - The range to check against (null means no constraint)
+ * @returns true if difficulty is within range or no range specified
+ */
+function isWithinDifficultyRange(difficulty, range) {
+    if (!range)
+        return true;
+    if (difficulty < range.min)
+        return false;
+    if (range.max !== undefined && difficulty >= range.max)
+        return false;
+    return true;
+}

package/dist/util/index.d.ts

@@ -1,6 +1,7 @@
 export * from './AvatarUri';
 export * from './ConditionMatcher';
 export * from './Database';
+export * from './DifficultyRange';
 export * from './Encryption';
 export * from './Logging';
 export * from './SenseRankEncoder';

package/dist/util/index.js

@@ -18,6 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AvatarUri"), exports);
 __exportStar(require("./ConditionMatcher"), exports);
 __exportStar(require("./Database"), exports);
+__exportStar(require("./DifficultyRange"), exports);
 __exportStar(require("./Encryption"), exports);
 __exportStar(require("./Logging"), exports);
 __exportStar(require("./SenseRankEncoder"), exports);

package/package.json

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