@project-sunbird/collection-editor-react 1.0.0 → 1.0.3

package/dist/utils/lpStructure.d.ts

@@ -0,0 +1,151 @@
+import { INode } from '../types/editor';
+export interface HierarchyLeafLike {
+    objectType?: string;
+    mimeType?: string;
+    children?: HierarchyLeafLike[];
+}
+/**
+ * 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:
+ *  - mapToINode marks linked courses (collection mimeType) as folders and
+ *    expands their internal children — in the LP tree courses are terminal
+ *    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.
+ */
+export declare function normalizeLearningPathTree(root: INode): Promise<INode>;
+export type LevelRole = 'pre' | 'post' | 'levelAssessment' | 'content';
+export declare function isAssessmentLevel(level: INode | undefined): boolean;
+/**
+ * getLevelRole(levelIndex, levelCount, hasAssessmentCourse) → role.
+ * Level[0] wrapping an assessment course is Prior/diagnostic ("pre");
+ * Level[levelCount-1] wrapping one is Outcome/summative ("post"); an
+ * assessment course inside any other Level is a Level assessment; anything
+ * else is a regular content Level. When levelCount === 1 the sole Level is
+ * treated as "pre" (index-0 check wins the tie) rather than "post".
+ */
+export declare function getLevelRole(levelIndex: number, levelCount: number, hasAssessmentCourse: boolean): LevelRole;
+/**
+ * Display info for one of root's Level children, keyed by id — same
+ * numbering rule TreeNode uses for its "Level N • {name}" row (assessment
+ * slots excluded from the count), reused by the Course-detail page's
+ * "Back to {label}" button so the two stay consistent.
+ */
+export declare function getLevelDisplayInfo(levels: INode[], levelId: string): {
+    role: 'pre' | 'post' | 'level';
+    levelNumber: number | null;
+} | null;
+/** Whether the pre (index 0) / post (last index) assessment slot already
+ *  wraps an assessment course, given root's current Level children. */
+export declare function isAssessmentSlotFilled(levels: INode[], slot: 'pre' | 'post'): boolean;
+/** Whether `level` (a direct child of root) is genuinely the pre/post
+ *  assessment slot — position AND shape, unlike bare `isAssessmentLevel`.
+ *  For callers (outside this module) that hold the level object rather
+ *  than its index. */
+export declare function isPrePostSlot(levels: INode[], level: INode | undefined): 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
+ * first, so a lone empty path always fills "pre" before "post" — matching
+ * getLevelRole's tie-break for levelCount === 1. Returns null once both
+ * slots are already wrapping an assessment course.
+ */
+export declare function resolveOpenAssessmentSlot(levels: INode[]): 'pre' | 'post' | null;
+/**
+ * Guards reorder of root's direct Level children: the pre-assessment Level
+ * (if any) must stay pinned at index 0 and the post-assessment Level (if any)
+ * must stay pinned at the last index; reordering is only free for the
+ * 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.
+ */
+export declare function canReorderLevel(levels: INode[], fromIndex: number, toIndex: number): boolean;
+/**
+ * Guards adding a course into a Level (doc rules, Phase 2 item 4): a
+ * pre/post assessment slot holds exactly one course, ever; a content Level
+ * allows any number of regular courses plus at most one Level assessment (a
+ * course flagged isAssessmentCourse). `isTargetPrePostSlot` must be computed
+ * via `isPrePostSlot` (position-aware) — bare shape (`isAssessmentLevel`)
+ * alone would also match a content Level whose only current course happens
+ * to be its Level assessment, wrongly blocking further regular courses on
+ * an otherwise-open Level.
+ */
+export declare function canAddCourseToLevel(level: INode | undefined, incomingIsAssessmentCourse: boolean, isTargetPrePostSlot: boolean): boolean;
+/**
+ * The LP root's explicitly-chosen Curriculum (framework) — from a prior save
+ * or the current session's Curriculum field, checked via treeCache first
+ * since a live edit lands there before a save round-trips it into
+ * root.metadata. Deliberately NOT the same as the channel/context default
+ * framework (useEditorStore's contentFramework, resolved so *something*
+ * exists to browse/filter by before the author has chosen anything) — that
+ * fallback must never be mistaken for a real choice, or courses linked
+ * under it get pruned the moment a real Curriculum is set, and the Library
+ * would silently scope itself to a framework the author never picked.
+ */
+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
+ * 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[];
+export interface LpValidationIssue {
+    code: string;
+    message: string;
+    nodeId?: string;
+}
+export declare const REQUIRES_PRIOR_POLICIES: Set<string>;
+/**
+ * Every synchronous (no network) LP publish rule: consumption policy set;
+ * prior assessment required only for Diagnostic/PriorLearning (not Fixed —
+ * confirmed open question #1); outcome assessment required always; pre/post
+ * slot purity; every content Level has ≥1 course and ≥1 in-scope skill; no
+ * empty Levels; every linked course carries a skill tag; no duplicate course
+ * across the path. `skillScope` empty means "no scope constraint yet"
+ * (matches useSkillScope's manual-fallback catalog, not an empty scope).
+ */
+export declare function validateLearningPathStructure(root: INode | undefined, skillCategoryCode: string | undefined, skillScope: string[]): 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.
+ */
+export declare function revalidateAssessmentSlots(root: INode | undefined): Promise<LpValidationIssue[]>;

package/dist/utils/lpStructure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/validateRequiredFields.d.ts

@@ -1,7 +1,6 @@
 import { INode } from '../types/editor';
 import { IFrameworkDetails } from '../types/framework';
 import { IPrepareContext } from '../components/SparkMetaForm/hooks/useFieldPrepare';
-
 export interface MissingFieldsReport {
     nodeId: string;
     nodeName: string;

package/dist/web-component/configRoundTrip.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@project-sunbird/collection-editor-react",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",
@@ -57,12 +57,21 @@
     "@vitejs/plugin-react": "^4.3.1",
     "sass": "^1.77.6",
     "typescript": "^5.5.3",
-    "vite": "^5.3.4",
-    "vite-plugin-dts": "^3.9.1",
-    "vitest": "^2.0.3"
+    "vite": "^6.4.3",
+    "vite-plugin-dts": "^5.0.3",
+    "vitest": "^3.2.7"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "overrides": {
+    "@microsoft/api-extractor": {
+      "lodash": "^4.18.0",
+      "minimatch": "^3.1.3"
+    },
+    "@microsoft/tsdoc-config": {
+      "ajv": "^6.14.0"
+    }
   }
 }