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

package/dist/utils/lpStructure.d.ts

@@ -1,17 +1,28 @@
 import { INode } from '../types/editor';
-export declare const EVALUATION_COURSE_CATEGORY = "Evaluation Course";
+export interface HierarchyLeafLike {
+    objectType?: string;
+    mimeType?: string;
+    children?: HierarchyLeafLike[];
+}
 /**
- * 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;
+ * 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;
 /**
  * Repairs a freshly-loaded LP tree (useEditorInit, after readHierarchy).
  * The hierarchy read undoes two editor-local invariants:
@@ -20,19 +31,13 @@ export declare function isEvaluationCourse(course: {
  *    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. Recomputed
- *    from the course's OWN primaryCategory — always present on the loaded
- *    node, no network read needed.
+ *    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.
  */
-export declare function normalizeLearningPathTree(root: INode): INode;
+export declare function normalizeLearningPathTree(root: INode): Promise<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");
@@ -60,20 +65,6 @@ 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
@@ -89,13 +80,6 @@ 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;
 /**
@@ -122,15 +106,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;
-/**
- * "Path shape" (root summary, Phase 4): level count excludes the pre/post
- * assessment slots (design: "Neither counts as a level"); course count
- * includes every linked course, assessment courses included.
- */
-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
@@ -140,6 +115,15 @@ export declare function computePathShape(root: INode | undefined): {
  * 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
+ * includes every linked course, assessment courses included.
+ */
+export declare function computePathShape(root: INode | undefined): {
+    levelCount: number;
+    courseCount: number;
+};
 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
@@ -193,12 +177,10 @@ 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 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.
+ * 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.
  */
 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.14",
+  "version": "1.0.15",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",

package/dist/components/UnitContentList/LevelCourseItem.d.ts

@@ -1,9 +0,0 @@
-import { default as React } from 'react';
-import { INode } from '../../types/editor';
-interface LevelCourseItemProps {
-    item: INode;
-    onRemove: (id: string) => void;
-    isEditable: boolean;
-}
-export declare const LevelCourseItem: React.FC<LevelCourseItemProps>;
-export {};

package/dist/components/UnitContentList/LevelExamItem.d.ts

@@ -1,7 +0,0 @@
-import { default as React } from 'react';
-interface LevelExamItemProps {
-    levelId: string | null | undefined;
-    isEditable: boolean;
-}
-export declare const LevelExamItem: React.FC<LevelExamItemProps>;
-export {};

package/dist/hooks/useLevelExam.d.ts

@@ -1,18 +0,0 @@
-import { INode } from '../types/editor';
-export interface UseLevelExamResult {
-    course: INode | undefined;
-    filled: boolean;
-    courseName: string | undefined;
-    isActiveTarget: boolean;
-    armExam: () => void;
-    deleteExam: () => void;
-}
-/**
- * Level Exam course for a single content Level — the optional, at-most-one
- * course (canAddCourseToLevel already caps it) whose leaves are purely a
- * question set, used to determine the learner's outcome for THIS Level
- * specifically (distinct from the Prior/Outcome Assessments, which gate the
- * whole path). Mirrors useAssessmentSlots.ts's shape, scoped to one Level
- * (by id) instead of root's pinned pre/post positions.
- */
-export declare function useLevelExam(levelId: string | null | undefined): UseLevelExamResult;