@project-sunbird/collection-editor-react 1.0.11 → 1.0.14

package/dist/utils/lpStructure.d.ts

@@ -1,28 +1,17 @@
 import { INode } from '../types/editor';
-export interface HierarchyLeafLike {
-    objectType?: string;
-    mimeType?: string;
-    children?: HierarchyLeafLike[];
-}
+export declare const EVALUATION_COURSE_CATEGORY = "Evaluation Course";
 /**
- * True iff the course has at least one leaf and every leaf is a QuML
- * QuestionSet — legacy ECML assessment resources
- * (application/vnd.ekstep.ecml-archive) do NOT qualify even though they're
- * historically labelled "assessment" content. An empty course (no leaves at
- * all) is not an assessment course.
- */
-export declare function isAssessmentCourse(course: HierarchyLeafLike): boolean;
-export interface AssessmentCourseInfo {
-    qualifies: boolean;
-    /** The course's full metadata from its own hierarchy read (children stripped).
-     *  Needed because composite-search results only carry the LP framework's
-     *  skill field — a course tagged under a different framework (e.g. USF)
-     *  would otherwise land in the tree without its framework or skill tags. */
-    meta: Record<string, unknown>;
-}
-export declare function getAssessmentCourseInfo(courseId: string): Promise<AssessmentCourseInfo>;
-export declare function checkAssessmentCourse(courseId: string): Promise<boolean>;
-export declare function clearAssessmentCourseCache(): void;
+ * A course qualifies for the Prior/Outcome Assessment slots and a Level
+ * Exam only by being explicitly authored under the Evaluation Course
+ * primaryCategory (whose own profile restricts its content to Question
+ * Sets/Course Assessment — see evaluationCourseProfile) — never by
+ * inspecting its content shape. This is a synchronous, no-network check:
+ * every course node (from a search result or a loaded hierarchy) already
+ * carries its own primaryCategory.
+ */
+export declare function isEvaluationCourse(course: {
+    primaryCategory?: string;
+} | undefined): boolean;
 /**
  * Repairs a freshly-loaded LP tree (useEditorInit, after readHierarchy).
  * The hierarchy read undoes two editor-local invariants:
@@ -31,13 +20,19 @@ export declare function clearAssessmentCourseCache(): void;
  *    leaves, so re-flatten them;
  *  - the isAssessmentCourse flag is local-only (stripped from saves), so
  *    without it no Level is recognized as a pre/post slot and "Skills
- *    covered"/slot rules read the path as having no assessments. Recompute
- *    it from the course's expanded subtree when the read included one, else
- *    (single-course first/last Levels only) via a checkAssessmentCourse read.
+ *    covered"/slot rules read the path as having no assessments. Recomputed
+ *    from the course's OWN primaryCategory — always present on the loaded
+ *    node, no network read needed.
  */
-export declare function normalizeLearningPathTree(root: INode): Promise<INode>;
+export declare function normalizeLearningPathTree(root: INode): INode;
 export type LevelRole = 'pre' | 'post' | 'levelAssessment' | 'content';
 export declare function isAssessmentLevel(level: INode | undefined): boolean;
+/** The at-most-one Level Exam course linked directly to a content Level, if
+ *  any — canAddCourseToLevel already caps this at one. Unlike
+ *  isAssessmentLevel, doesn't require it to be the Level's ONLY child (a
+ *  Level Exam course sits alongside however many regular courses that
+ *  Level also has). */
+export declare function getLevelExamCourse(level: INode | undefined): INode | undefined;
 /**
  * getLevelRole(levelIndex, levelCount, hasAssessmentCourse) → role.
  * Level[0] wrapping an assessment course is Prior/diagnostic ("pre");
@@ -65,6 +60,20 @@ export declare function isAssessmentSlotFilled(levels: INode[], slot: 'pre' | 'p
  *  For callers (outside this module) that hold the level object rather
  *  than its index. */
 export declare function isPrePostSlot(levels: INode[], level: INode | undefined): boolean;
+/**
+ * True iff `levelNode` sits at index 0 or the last index among root's
+ * Levels AND currently has no courses at all — i.e. adding a single
+ * QuestionSet-only course here next would leave it indistinguishable from
+ * a genuine Prior/Outcome Assessment slot (isAssessmentLevel: exactly one
+ * course, and that one flagged isAssessmentCourse — there's no separate
+ * marker recording *why* a Level ended up in that shape). A Level anywhere
+ * else, or one that already has ≥1 course, never hits this ambiguity — a
+ * second course makes children.length !== 1, so isAssessmentLevel can't
+ * match regardless of shape (this is also why a Level Exam Course paired
+ * with other regular content in the same Level is unaffected: only a
+ * Level reduced to just the one QuestionSet-only course is at risk).
+ */
+export declare function wouldBecomeAmbiguousSlot(rootLevels: INode[], levelNode: INode): boolean;
 /**
  * Which pre/post assessment slot (if any) is open to receive a newly-linked
  * assessment course, given root's current Level children. Pre is checked
@@ -80,6 +89,13 @@ export declare function resolveOpenAssessmentSlot(levels: INode[]): 'pre' | 'pos
  * content Levels between them. Simulates the same splice-based move
  * `reorderInParent` performs and checks the pinned Levels didn't shift,
  * rather than hand-deriving index-shift arithmetic.
+ *
+ * Also blocks moving a content Level (one that ISN'T already a pinned pre/
+ * post slot) into index 0 or the last index if it would land there already
+ * shaped like one (isAssessmentLevel — exactly one course, flagged) — e.g. a
+ * content Level whose only remaining course is its Level Exam course. Same
+ * ambiguity wouldBecomeAmbiguousSlot guards on add; without this, reordering
+ * could produce the identical shape without ever going through that check.
  */
 export declare function canReorderLevel(levels: INode[], fromIndex: number, toIndex: number): boolean;
 /**
@@ -106,15 +122,6 @@ export declare function canAddCourseToLevel(level: INode | undefined, incomingIs
  */
 export declare function getExplicitCurriculum(root: INode | undefined, treeCache: Record<string, Record<string, unknown>>): string | undefined;
 export declare function hasExplicitCurriculum(root: INode | undefined, treeCache: Record<string, Record<string, unknown>>): boolean;
-/**
- * "Skills covered" (root summary, Phase 4): the union of skills tagged
- * across the Prior Assessment, each Level's *selected* skills, and the
- * Outcome Assessment — never skills scraped from linked courses' content.
- * Both assessment Levels (their course's tags) and content Levels (their
- * own selection) read the SAME resolved skillCategoryCode metadata field —
- * never the reserved Sunbird `competencies` field, whose platform schema
- * expects competency-ontology objects, not plain framework-term strings.
- */
 /**
  * "Path shape" (root summary, Phase 4): level count excludes the pre/post
  * assessment slots (design: "Neither counts as a level"); course count
@@ -124,6 +131,15 @@ export declare function computePathShape(root: INode | undefined): {
     levelCount: number;
     courseCount: number;
 };
+/**
+ * "Skills covered" (root summary, Phase 4): the union of skills tagged
+ * across the Prior Assessment, each Level's *selected* skills, and the
+ * Outcome Assessment — never skills scraped from linked courses' content.
+ * Both assessment Levels (their course's tags) and content Levels (their
+ * own selection) read the SAME resolved skillCategoryCode metadata field —
+ * never the reserved Sunbird `competencies` field, whose platform schema
+ * expects competency-ontology objects, not plain framework-term strings.
+ */
 export declare function computeSkillsCovered(root: INode | undefined, skillCategoryCode: string | undefined): string[];
 /**
  * The skills-covered union that should be persisted onto the LP root's OWN
@@ -177,10 +193,12 @@ export declare const REQUIRES_PRIOR_POLICIES: Set<string>;
  */
 export declare function validateLearningPathStructure(root: INode | undefined, skillCategoryCode: string | undefined, skillScope: string[], treeCache?: Record<string, Record<string, unknown>>): LpValidationIssue[];
 /**
- * Re-verifies the pre/post assessment courses are STILL question-set-only at
- * publish time (Phase 1 item 6 / Phase 5: "the course may have changed since
- * it was linked"). Separate from validateLearningPathStructure because it
- * requires a network read; callers should run it alongside the sync checks,
- * not instead of them.
+ * Re-verifies the pre/post assessment courses are STILL categorized
+ * Evaluation Course at publish time — an author could re-tag a linked
+ * course's category after it was added to the path. A lightweight
+ * collection read (not a hierarchy walk — qualification is a single
+ * metadata field now) suffices. Separate from validateLearningPathStructure
+ * because it requires a network read; callers should run it alongside the
+ * sync checks, not instead of them.
  */
 export declare function revalidateAssessmentSlots(root: INode | undefined): Promise<LpValidationIssue[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@project-sunbird/collection-editor-react",
-  "version": "1.0.11",
+  "version": "1.0.14",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",