lens-content-processor 0.78.0 → 0.80.0

package/dist/index.d.ts

@@ -358,15 +358,181 @@ export interface Frame {
 export type Segment = (TextSegment | ChatSegment | ArticleSegment | VideoSegment | QuestionSegment | RoleplaySegment | InterviewSegment | EmbedSegment | WidgetSegment) & {
     frames?: Frame[];
 };
+import { type ImportedOutcome } from "./flattener/index.js";
+import { type DroppedEntry } from "./dropped.js";
+import { type ErrorCandidate } from "./dedupe-errors.js";
+import { type ParsedLearningOutcome } from "./parser/learning-outcome.js";
+import { type UuidEntry } from "./validator/uuid.js";
 import { type TranscriptSentence, type VideoSkip } from "./bundler/video.js";
 export type { TranscriptSentence, VideoSkip } from "./bundler/video.js";
 export { parseWidget, isWidgetPath, isWidgetFile } from "./parser/widget.js";
-import { type GlossaryDefinition, type GlossaryMark } from "./glossary.js";
+import { type GlossaryDefinition, type GlossaryEntry, type GlossaryMark } from "./glossary.js";
 import { type OptionalLensSet } from "./validator/optional-lens-sets.js";
 export type { ContentTier } from "./validator/tier.js";
 export { checkTierViolation } from "./validator/tier.js";
-import { type SkillTree } from "./skill-tree.js";
+import { type SkillTree, type SkillTreeModule } from "./skill-tree.js";
 export type { SkillTree, SkillTreeCard, SkillTreeDomain, SkillTreeTopic, TaughtByCourse, TaughtByModule, } from "./skill-tree.js";
+import { type ParsedDomainMetadata, type ParsedTopicFile } from "./parser/domain.js";
 import { FileResultCache } from "./cache.js";
+import { RunInputs } from "./dependency-cache.js";
 export { FileResultCache } from "./cache.js";
+import { type ContentViews, type TierMap } from "./engine/reader.js";
+/** A Learning Outcome a module file imports, and the submodule it sits in. */
+interface ModuleLoRef {
+    lo: string;
+    submodule: {
+        slug: string;
+        title: string;
+    } | null;
+}
+/**
+ * What one content file adds to the whole content: its errors and pages, and
+ * its entries in the tables that wholeContentStep builds across files. A unit
+ * reads other files only through its views and never another unit's result,
+ * so units are independent: they can run in any order, alone, or be reused
+ * from an earlier build (src/engine/build.ts). Arrays keep the order today's
+ * single pass pushed in; the other fields are keyed by this file's path.
+ */
+export interface PathContribution {
+    path: string;
+    errors: ContentError[];
+    /** The pages this file produces, in output order. */
+    modules: FlattenedModule[];
+    urls: UrlToValidate[];
+    uuids: UuidEntry[];
+    course?: Course;
+    survey?: FlattenedSurvey;
+    meetingDoc?: string;
+    articleSegments?: Segment[];
+    /** A module file's slug in course progressions (a split module's parent slug). */
+    moduleSlug?: string;
+    skillTreeModule?: SkillTreeModule;
+    learningOutcome?: ParsedLearningOutcome;
+    loRefs?: ModuleLoRef[];
+    /** The `Domains and Topics/` folder this file is in. */
+    domainFolder?: {
+        dir: string;
+        number: number;
+        title: string;
+        metadata?: ParsedDomainMetadata;
+    };
+    topic?: ParsedTopicFile & {
+        domainDir: string;
+    };
+    glossaryEntry?: GlossaryEntry;
+    /** What errors left out of this file's pages, or the page it could not make (src/dropped.ts). */
+    dropped?: DroppedEntry[];
+}
+/** One file's pass: parse it, run its own checks, and flatten its pages. */
+export declare function runPathUnit(path: string, { files, tierMap, tagMap }: ContentViews, steps?: RunInputs): PathContribution;
 export declare function processContent(files: Map<string, string>, cache?: FileResultCache): ProcessResult;
+/**
+ * Everything after the file units: the whole-content step, every page
+ * finished, and the errors in today's order. `units` holds one entry per
+ * content file, in path order; their pages are finished in place. The engine
+ * runs the same three steps on stored results (engine/build.ts), so a rule
+ * changes in one place for both.
+ */
+export declare function assembleContent(units: PathContribution[], views: ContentViews): ProcessResult;
+/** What the whole-content step needs to know of one flattened page. */
+export interface PageFacts {
+    slug: string;
+    parentSlug?: string;
+    /** The contentId of every section that has one, in section order. */
+    contentIds: string[];
+    /** Every test section that names its outcome file: the outcomes it tests. */
+    tests: {
+        sourcePath: string;
+        outcomes: LearningOutcomeRef[];
+    }[];
+}
+/** A unit's contribution as the whole-content step reads it: no page bodies. */
+export type UnitSummary = Omit<PathContribution, "modules"> & {
+    pages: PageFacts[];
+};
+export declare function summarizeUnit({ modules, ...unit }: PathContribution): UnitSummary;
+/**
+ * The whole-content tables that finishing a page reads. The engine reads
+ * them through recording views (engine/tables.ts), so a page is finished
+ * again when an entry it used changes.
+ */
+export interface FinishTables {
+    /** Lens content id → the module page that holds it (the last in page order; standalone lens pages never). */
+    contentIdToModule: ReadonlyMap<string, string>;
+    /** Glossary entry file → its entry. */
+    glossary: ReadonlyMap<string, GlossaryEntry>;
+    /** Module group (`parentSlug ?? slug`) → the content ids of its sections. */
+    moduleContentIds: ReadonlyMap<string, string[]>;
+    /** Page slug → its file (the last page with the slug wins). */
+    slugToPath: ReadonlyMap<string, string>;
+    /** Page key → for each course the page is in, in course order, the outcomes tested in that course. */
+    courseOutcomes: ReadonlyMap<string, ImportedOutcome[][]>;
+    /** Learning outcome id → its primary skill-tree topic. */
+    topics: ReadonlyMap<string, NonNullable<LearningOutcomeRef["topic"]>>;
+}
+/** What the whole-content step builds: tables, outputs, and its checks' errors. */
+export interface WholeContent {
+    /** Errors of the checks across files, by their place in today's order (assembleErrors). */
+    errors: {
+        glossaryAliases: ContentError[];
+        courses: ContentError[];
+        uuids: ContentError[];
+        slugsAndTranscripts: ContentError[];
+        skillTree: ContentError[];
+    };
+    tables: FinishTables;
+    courses: Course[];
+    surveys: FlattenedSurvey[];
+    meetingDocs: Record<string, string>;
+    urlsToValidate: UrlToValidate[];
+    skillTree: SkillTree;
+    articleSegments: Record<string, Segment[]>;
+}
+/**
+ * The whole-content step: merge every file's summary into the tables that
+ * span files and run the checks across files. It reads facts and page
+ * summaries, never a page body. `units` holds one entry per content file, in
+ * path order; their courses and question entries are changed in place.
+ */
+export declare function wholeContentStep(units: Iterable<UnitSummary>, { files, tierMap, tagMap }: ContentViews): WholeContent;
+/** What finishing one page reports, by each list's place in today's order (assembleErrors). */
+export interface PageFinish {
+    glossary: ContentError[];
+    cardMembership: ContentError[];
+    optionalLensSets: ContentError[];
+    sharedQuestions: ErrorCandidate[];
+    integrity: ErrorCandidate[];
+}
+/**
+ * Finish one flattened page with what other pages contribute: a card's and a
+ * lens link's module, glossary marks, optional-lens lists, outcomes tested
+ * elsewhere in a course, and outcome topics; and run the checks on the
+ * finished page. Changes `page` in place, so it starts from a page fresh
+ * from flattening: a card's module, once set, is never cleared. `key` is
+ * pageKey of the page.
+ *
+ * Anything a page takes from other pages belongs here, never in flattening.
+ * Flattening runs in one file's unit before the other units have run, so a
+ * value it took from another page would go stale when that page changes,
+ * with no test failing at once.
+ */
+export declare function finishPage(page: FlattenedModule, key: string, tables: FinishTables, { files, tierMap }: ContentViews): PageFinish;
+/**
+ * The final error list in today's order: every unit's errors in path order,
+ * then the checks after the file units in the order they ran, the page
+ * checks in page order within their step. Each error gets its category (the
+ * tier of its file), and dedupeErrors' rule keeps the first copy. `sources`
+ * names, for each final error, the sources (as given) that reported it.
+ */
+export declare function assembleErrors(units: Iterable<{
+    source: string;
+    errors: ContentError[];
+}>, whole: WholeContent["errors"], pages: readonly {
+    source: string;
+    finish: PageFinish;
+}[], tierMap: TierMap): {
+    errors: ContentError[];
+    sources: string[][];
+};
+/** The ProcessResult of finished pages, the whole-content step and the final errors. */
+export declare function processResult(modules: FlattenedModule[], whole: WholeContent, errors: ContentError[]): ProcessResult;