@royalschedule/maps 4.1.4 → 4.1.5

package/dist/Excel/v2/from/index.mjs

@@ -0,0 +1,620 @@
+import { makeChainable } from "../../../common/make-chainable/index.mjs";
+import { countBy, isNumber, isString } from "lodash-es";
+import { nanoid } from "nanoid";
+
+//#region src/Excel/v2/from/index.ts
+function generateId(map) {
+	let id;
+	do
+		id = nanoid(8);
+	while (map.has(id));
+	return id;
+}
+function toPositiveMultipleOf5(val) {
+	const num = isString(val) ? parseInt(val) : val;
+	if (isNaN(num)) throw new Error(`toMultipleOf5: ${val} is not a number`);
+	const res = Math.floor(num / 5) * 5;
+	if (res <= 0) throw new Error(`toMultipleOf5: the result ${res} is not positive`);
+	return res;
+}
+function toPositiveInteger(val) {
+	const num = isString(val) ? parseInt(val) : val;
+	if (isNaN(num)) throw new Error(`toInteger: ${val} is not a number`);
+	if (num <= 0) throw new Error(`toInteger: te result ${num} is not positive`);
+	return num;
+}
+/**
+* Converts a string/number to a trimmed string
+*/
+function toString(x) {
+	return isNumber(x) ? x.toString() : x.trim();
+}
+/**
+* Converts a possible nullish string/number to a trimmed string or undefined
+*/
+function toStringIfExists(x) {
+	if (x == null) return void 0;
+	return toString(x);
+}
+function toNumberIfExists(x) {
+	if (x == null) return void 0;
+	const num = isString(x) ? parseInt(x) : x;
+	if (isNaN(num)) return void 0;
+	return num;
+}
+function extractLocations(course, locationsNameMap, warnings) {
+	if (course.locations == null) return;
+	const locationsStr = toString(course.locations);
+	if (!locationsStr) return;
+	const locationReferences = [];
+	locationsStr.split("+").flatMap((x, i) => x.split(",").map((x) => [i, x.trim()])).forEach(([i, x]) => {
+		const key = x.toLowerCase();
+		const ref = locationsNameMap.get(key);
+		if (!ref) {
+			warnings.push({
+				code: "invalid_location_reference",
+				context: x
+			});
+			return;
+		}
+		if (locationReferences.some((y) => y.to == ref.id)) {
+			warnings.push({
+				code: "location_referenced_multiple_times",
+				context: x
+			});
+			return;
+		}
+		locationReferences.push({
+			groupIndex: i,
+			to: ref.id
+		});
+	});
+	return locationReferences;
+}
+function extractGroups(course, groupsNameMap, warnings) {
+	if (course.groups == null) return;
+	const groupsStr = toString(course.groups);
+	if (!groupsStr) return;
+	const groupReferences = [];
+	groupsStr.split(",").map((x) => x.trim()).forEach((x) => {
+		const key = x.toLowerCase();
+		const ref = groupsNameMap.get(key);
+		if (!ref) {
+			warnings.push({
+				code: "invalid_group_reference",
+				context: x
+			});
+			return;
+		}
+		if (groupReferences.some((y) => y.to == ref.id)) {
+			warnings.push({
+				code: "group_referenced_multiple_times",
+				context: x
+			});
+			return;
+		}
+		groupReferences.push({ to: ref.id });
+	});
+	return groupReferences;
+}
+function extractTeachers(course, teachersNameMap, teachersSignatureMap, warnings) {
+	if (course.teachers == null) return;
+	const teachersStr = toString(course.teachers);
+	if (!teachersStr) return void 0;
+	const teacherReferences = [];
+	teachersStr.split(",").map((x) => x.trim()).forEach((x) => {
+		const key = x.toLowerCase();
+		const refName = teachersNameMap.get(key);
+		const refSignature = teachersSignatureMap.get(key);
+		const ref = refName || refSignature;
+		if (!ref) {
+			warnings.push({
+				code: "invalid_teacher_reference",
+				context: x
+			});
+			return;
+		}
+		if (teacherReferences.some((y) => y.to == ref.id)) {
+			warnings.push({
+				code: "teacher_referenced_multiple_times",
+				context: x
+			});
+			return;
+		}
+		teacherReferences.push({ to: ref.id });
+	});
+	return teacherReferences;
+}
+function extractSyllabus(course, syllabusesCodeMap, syllabusesNameMap, warnings) {
+	if (course.syllabus == null) return void 0;
+	const syllabusValue = toString(course.syllabus);
+	if (!syllabusValue) return void 0;
+	const syllabus = syllabusesCodeMap.get(syllabusValue) || syllabusesNameMap.get(syllabusValue.toLowerCase());
+	if (!syllabus) {
+		warnings.push({
+			code: "invalid_syllabus_reference",
+			context: syllabusValue
+		});
+		return;
+	}
+	return syllabus.id;
+}
+function getSetsFromCourses(courses) {
+	const coursesWithEvents = courses.map((c) => c.events ?? []).filter((events) => events.length > 0);
+	if (coursesWithEvents.length < 2) return [];
+	const numSets = Math.min(...coursesWithEvents.map((events) => events.length));
+	const sortedCourses = coursesWithEvents.map((events) => [...events].sort((a, b) => a.preferredDuration - b.preferredDuration));
+	const referenceCourses = sortedCourses.filter((events) => events.length === numSets);
+	const targets = Array.from({ length: numSets }, (_, i) => {
+		const durations = referenceCourses.map((events) => events[i].preferredDuration).sort((a, b) => a - b);
+		return durations[Math.floor(durations.length / 2)];
+	});
+	const prunedCourses = sortedCourses.map((events) => {
+		if (events.length === numSets) return events;
+		return selectBestSubset(events, targets);
+	});
+	const sets = [];
+	for (let i = 0; i < numSets; i++) sets.push(prunedCourses.map((events) => events[i]));
+	return sets;
+}
+/**
+* Picks `targets.length` events from a sorted event list to minimise total
+* absolute deviation from the target durations.  Uses O(n·k) DP.
+*/
+function selectBestSubset(events, targets) {
+	const n = events.length;
+	const k = targets.length;
+	const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(Infinity));
+	for (let i = 0; i <= n; i++) dp[i][0] = 0;
+	for (let i = 1; i <= n; i++) for (let j = 1; j <= Math.min(i, k); j++) {
+		dp[i][j] = dp[i - 1][j];
+		const cost = Math.abs(events[i - 1].preferredDuration - targets[j - 1]);
+		if (dp[i - 1][j - 1] + cost < dp[i][j]) dp[i][j] = dp[i - 1][j - 1] + cost;
+	}
+	const selected = [];
+	let j = k;
+	for (let i = n; i >= 1 && j > 0; i--) {
+		const cost = Math.abs(events[i - 1].preferredDuration - targets[j - 1]);
+		if (dp[i][j] === dp[i - 1][j - 1] + cost) {
+			selected.unshift(events[i - 1]);
+			j--;
+		}
+	}
+	return selected;
+}
+function _schedules(source) {
+	const warnings = [];
+	source.settings = source.settings?.filter((x) => Object.values(x).some((y) => toString(y).length > 0));
+	source.locations = source.locations?.filter((x) => Object.values(x).some((y) => toString(y).length > 0));
+	source.teachers = source.teachers?.filter((x) => Object.values(x).some((y) => toString(y).length > 0));
+	source.groups = source.groups?.filter((x) => Object.values(x).some((y) => toString(y).length > 0));
+	source.persons = source.persons?.filter((x) => Object.values(x).some((y) => toString(y).length > 0));
+	source.courses = source.courses?.filter((x) => Object.values(x).some((y) => toString(y).length > 0));
+	const settings = {
+		discretization: 5,
+		numDays: 5,
+		dayStart: "08:00",
+		dayEnd: "17:00"
+	};
+	if (!source.settings) warnings.push({ code: "missing_settings_sheet" });
+	if (source.settings?.[0]?.number_of_days) {
+		const numDays = source.settings?.[0]?.number_of_days;
+		try {
+			settings.numDays = toPositiveInteger(numDays);
+			if (settings.numDays !== 5 && settings.numDays !== 7) {
+				warnings.push({
+					code: "invalid_number_of_days",
+					context: numDays
+				});
+				settings.numDays = 5;
+			}
+		} catch {
+			warnings.push({
+				code: "invalid_number_of_days",
+				context: numDays
+			});
+		}
+	}
+	const syllabusesIdMap = /* @__PURE__ */ new Map();
+	const syllabusesNameMap = /* @__PURE__ */ new Map();
+	const syllabusesCodeMap = /* @__PURE__ */ new Map();
+	if (!source.syllabuses) {}
+	source.syllabuses?.forEach((x) => {
+		const ids = toStringIfExists(x.foreign_ID);
+		const subjectCode = toStringIfExists(x.subject_code);
+		const subjectName = toStringIfExists(x.subject_name);
+		const courseCode = toStringIfExists(x.course_code);
+		const courseName = toStringIfExists(x.course_name);
+		const schoolType = toStringIfExists(x.school_type);
+		const id = toStringIfExists(x.ID) ?? generateId(syllabusesIdMap);
+		if (syllabusesIdMap.has(id)) {
+			warnings.push({
+				code: "ignoring_duplicate_syllabus",
+				context: `${subjectName} (${courseName})`
+			});
+			return;
+		}
+		if (!subjectName) {
+			warnings.push({
+				code: "missing_subject_name",
+				context: x
+			});
+			return;
+		}
+		if (!schoolType) {
+			warnings.push({
+				code: "missing_school_type",
+				context: x
+			});
+			return;
+		}
+		const y = {
+			id,
+			...ids && { ids },
+			...subjectCode && { subjectCode },
+			subjectName,
+			...courseCode && { courseCode },
+			...courseName && { courseName },
+			schoolType,
+			official: true,
+			__raw: x
+		};
+		syllabusesIdMap.set(id, y);
+		const code = courseCode || subjectCode;
+		const name = courseName || subjectName;
+		if (code) syllabusesCodeMap.set(code, y);
+		if (name) syllabusesNameMap.set(name.toLowerCase(), y);
+	});
+	const locationsIdMap = /* @__PURE__ */ new Map();
+	const locationsNameMap = /* @__PURE__ */ new Map();
+	const teachersIdMap = /* @__PURE__ */ new Map();
+	const teachersNameMap = /* @__PURE__ */ new Map();
+	const teachersSignatureMap = /* @__PURE__ */ new Map();
+	[{
+		name: {
+			singular: "location",
+			plural: "locations"
+		},
+		data: source.locations,
+		idMap: locationsIdMap,
+		nameMap: locationsNameMap,
+		signatureMap: void 0
+	}, {
+		name: {
+			singular: "teacher",
+			plural: "teachers"
+		},
+		data: source.teachers,
+		idMap: teachersIdMap,
+		nameMap: teachersNameMap,
+		signatureMap: teachersSignatureMap
+	}].forEach(({ name, data, idMap, nameMap, signatureMap }) => {
+		if (!data) warnings.push({ code: `missing_${name.plural}_sheet` });
+		data?.forEach((x) => {
+			const ids = toStringIfExists(x.foreign_ID);
+			const displayName = toStringIfExists(x.name);
+			const id = toStringIfExists(x.ID) ?? generateId(idMap);
+			if (idMap.has(id)) {
+				warnings.push({
+					code: `ignoring_duplicate_${name.singular}`,
+					context: displayName
+				});
+				return;
+			}
+			const y = {
+				id,
+				...ids && { ids },
+				...displayName && { displayName },
+				__raw: x
+			};
+			idMap.set(id, y);
+			if (displayName) nameMap.set(displayName.toLowerCase(), y);
+			if (signatureMap && "signature" in x && x.signature) signatureMap.set(x.signature.toLowerCase(), y);
+		});
+	});
+	const groupsIdMap = /* @__PURE__ */ new Map();
+	const groupsNameMap = /* @__PURE__ */ new Map();
+	if (!source.groups) warnings.push({ code: "missing_groups_sheet" });
+	source.groups?.forEach((x) => {
+		const ids = toStringIfExists(x.foreign_ID);
+		const displayName = toStringIfExists(x.name);
+		const id = toStringIfExists(x.ID) ?? generateId(groupsIdMap);
+		if (groupsIdMap.has(id)) {
+			warnings.push({
+				code: "ignoring_duplicate_group",
+				context: displayName
+			});
+			return;
+		}
+		const species = toStringIfExists(x.is_class) == "1" ? "class" : void 0;
+		const y = {
+			id,
+			...ids && { ids },
+			...displayName && { displayName },
+			...species && { species },
+			__raw: x
+		};
+		groupsIdMap.set(id, y);
+		if (displayName) groupsNameMap.set(displayName.toLowerCase(), y);
+	});
+	const personsIdMap = /* @__PURE__ */ new Map();
+	const personsSsnMap = /* @__PURE__ */ new Map();
+	if (!source.persons) warnings.push({ code: "missing_persons_sheet" });
+	source.persons?.forEach((x) => {
+		const ids = toStringIfExists(x.foreign_ID);
+		const firstName = toStringIfExists(x.first_name);
+		const lastName = toStringIfExists(x.last_name);
+		const SSN = toStringIfExists(x.SSN);
+		const id = toStringIfExists(x.ID) ?? generateId(personsIdMap);
+		if (personsIdMap.has(id)) {
+			warnings.push({
+				code: "ignoring_duplicate_person",
+				context: `${firstName} ${lastName}`
+			});
+			return;
+		}
+		let group = void 0;
+		if (x.group) {
+			const key = toString(x.group).toLowerCase();
+			const ref = groupsNameMap.get(key);
+			if (!ref) warnings.push({
+				code: "invalid_group_reference",
+				context: x.group
+			});
+			else if (ref.species !== "class") warnings.push({
+				code: "forbidden_group_reference",
+				context: x.group
+			});
+			else group = ref.id;
+		}
+		let sex;
+		if (x.sex) if (isString(x.sex) && x.sex.toLowerCase() == "man") sex = "Man";
+		else if (isString(x.sex) && x.sex.toLowerCase() == "woman") sex = "Woman";
+		else warnings.push({
+			code: "invalid_sex",
+			context: x.sex
+		});
+		const person = {
+			id,
+			...ids && { ids },
+			...firstName && { firstName },
+			...lastName && { lastName },
+			...sex && { sex },
+			...group && { group },
+			...SSN && { SSN: { value: SSN } },
+			__raw: x
+		};
+		personsIdMap.set(id, person);
+		if (SSN) personsSsnMap.set(SSN, person);
+	});
+	groupsNameMap.forEach((x) => {
+		let duplicateReported = false;
+		if (!x.__raw.members) return;
+		x.members = makeChainable(x.__raw.members).chain((x) => toString(x).split(",").map((x) => x.trim()).filter((x) => x != null)).chain((x) => countBy(x)).chain((y) => Object.entries(y).map(([ssn, count]) => {
+			if (!ssn) return;
+			if (!duplicateReported && count > 1) {
+				warnings.push({
+					code: "duplicate_group_member",
+					context: x.displayName
+				});
+				duplicateReported = true;
+			}
+			const person = personsSsnMap.get(ssn);
+			if (!person) {
+				warnings.push({
+					code: "invalid_person_reference",
+					context: ssn
+				});
+				return;
+			}
+			if (x.species == "class") {
+				if (!person.group) person.group = x.id;
+				else if (person.group != x.id) {
+					warnings.push({
+						code: "person_in_multiple_classes",
+						context: ssn
+					});
+					return;
+				}
+			}
+			return person.id;
+		}).filter((x) => x != null)).value;
+	});
+	const coursesIdMap = /* @__PURE__ */ new Map();
+	const eventsIdMap = /* @__PURE__ */ new Map();
+	const linkedEventsParallelIdMap = /* @__PURE__ */ new Map();
+	const linkedEventsSequentialIdMap = /* @__PURE__ */ new Map();
+	const parallelLessonsMap = /* @__PURE__ */ new Map();
+	if (!source.courses) warnings.push({ code: "missing_courses_sheet" });
+	source.courses?.forEach((x) => {
+		if (toStringIfExists(x.merge_with)) return;
+		const ids = toStringIfExists(x.foreign_ID);
+		const displayName = toStringIfExists(x.name);
+		const subject = toStringIfExists(x.subject);
+		const courseId = toStringIfExists(x.ID) ?? generateId(coursesIdMap);
+		if (coursesIdMap.has(courseId)) {
+			warnings.push({
+				code: "ignoring_duplicate_course",
+				context: displayName + (subject ? ` (${subject})` : "")
+			});
+			return;
+		}
+		let expectedTotalHours = void 0;
+		if (x.total_hours) try {
+			expectedTotalHours = toPositiveInteger(x.total_hours);
+		} catch {
+			warnings.push({
+				code: "invalid_total_hours",
+				context: x.total_hours
+			});
+		}
+		let minutesPerWeek = void 0;
+		if (x.minutes_per_week) try {
+			minutesPerWeek = toPositiveMultipleOf5(x.minutes_per_week);
+		} catch {
+			warnings.push({
+				code: "invalid_minutes_per_week",
+				context: x.minutes_per_week
+			});
+		}
+		if (minutesPerWeek != null && expectedTotalHours != null) warnings.push({
+			code: "ambiguous_planned_duration",
+			context: `${minutesPerWeek} min/week OR ${expectedTotalHours} hrs`
+		});
+		const plannedDuration = expectedTotalHours ? `${expectedTotalHours} hrs` : minutesPerWeek ? `${minutesPerWeek} min/week` : void 0;
+		if (x.lesson_durations) {
+			const durations = (typeof x.lesson_durations === "string" ? x.lesson_durations.split(",").map((x) => x.trim()) : [x.lesson_durations]).map((e) => {
+				try {
+					return toPositiveMultipleOf5(e);
+				} catch {
+					warnings.push({
+						code: "invalid_lesson_durations",
+						context: x.lesson_durations
+					});
+					return;
+				}
+			}).filter((x) => x !== void 0);
+			let queuedSequentialEvent = null;
+			let createdSequentialEventsCount = 0;
+			durations.forEach((y) => {
+				const id = generateId(eventsIdMap);
+				const event = {
+					id,
+					course: courseId,
+					preferredDuration: y
+				};
+				const sequentialCount = toNumberIfExists(x.linked_lessons_sequential);
+				const parallelIdentifier = toStringIfExists(x.linked_lessons_parallel);
+				if (sequentialCount && parallelIdentifier) warnings.push({
+					code: "both_linked_lessons_fields_present",
+					context: x
+				});
+				else {
+					if (parallelIdentifier) {
+						if (!parallelLessonsMap.has(parallelIdentifier)) parallelLessonsMap.set(parallelIdentifier, []);
+						parallelLessonsMap.get(parallelIdentifier).push(event);
+					}
+					if (sequentialCount && createdSequentialEventsCount < sequentialCount) if (!queuedSequentialEvent) queuedSequentialEvent = event;
+					else {
+						const linkedEventsSetId = generateId(linkedEventsSequentialIdMap);
+						const linkedEventsSet = {
+							id: linkedEventsSetId,
+							type: "sequential",
+							gap: {
+								min: 0,
+								max: 10
+							},
+							events: [queuedSequentialEvent.id, event.id],
+							__raw: x
+						};
+						linkedEventsSequentialIdMap.set(linkedEventsSetId, linkedEventsSet);
+						queuedSequentialEvent = null;
+						createdSequentialEventsCount++;
+					}
+				}
+				eventsIdMap.set(id, event);
+			});
+		}
+		const locations = extractLocations(x, locationsNameMap, warnings)?.map((x) => ({
+			groupIndex: x.groupIndex,
+			locations: [x.to]
+		}));
+		const groups = extractGroups(x, groupsNameMap, warnings);
+		const teachers = extractTeachers(x, teachersNameMap, teachersSignatureMap, warnings);
+		const syllabus = extractSyllabus(x, syllabusesCodeMap, syllabusesNameMap, warnings);
+		const course = {
+			id: courseId,
+			...ids && { ids },
+			...displayName && { displayName },
+			...subject && { subject },
+			...expectedTotalHours && { expectedTotalHours },
+			...minutesPerWeek && { minutesPerWeek },
+			...plannedDuration && { plannedDuration },
+			...groups && { groups },
+			...teachers && { teachers },
+			...locations && { locations },
+			...syllabus && { syllabus },
+			__raw: x
+		};
+		coursesIdMap.set(courseId, course);
+	});
+	source.courses?.forEach((x) => {
+		const mergeWith = toStringIfExists(x.merge_with);
+		if (!mergeWith) return;
+		if (!coursesIdMap.has(mergeWith)) {
+			warnings.push({
+				code: "invalid_course_reference",
+				context: mergeWith
+			});
+			return;
+		}
+		const displayName = toStringIfExists(x.name);
+		const locations = extractLocations(x, locationsNameMap, warnings)?.map((x) => ({
+			groupIndex: x.groupIndex,
+			locations: [x.to]
+		}));
+		const groups = extractGroups(x, groupsNameMap, warnings);
+		const teachers = extractTeachers(x, teachersNameMap, teachersSignatureMap, warnings);
+		if (x.lesson_durations) (typeof x.lesson_durations === "string" ? x.lesson_durations.split(",").map((x) => x.trim()) : [x.lesson_durations]).map((e) => {
+			try {
+				return toPositiveMultipleOf5(e);
+			} catch {
+				warnings.push({
+					code: "invalid_lesson_durations",
+					context: x.lesson_durations
+				});
+				return;
+			}
+		}).filter((x) => x !== void 0).forEach((preferredDuration) => {
+			const id = generateId(eventsIdMap);
+			const event = {
+				id,
+				course: mergeWith,
+				preferredDuration,
+				...displayName && { displayName },
+				...groups && { groups },
+				...teachers && { teachers },
+				...locations && { locations },
+				__raw: x
+			};
+			eventsIdMap.set(id, event);
+		});
+	});
+	parallelLessonsMap.values().forEach((events) => {
+		if (events.length < 2) return;
+		const eventsByCourse = /* @__PURE__ */ new Map();
+		events.forEach((event) => {
+			const courseId = event.course;
+			if (!eventsByCourse.has(courseId)) eventsByCourse.set(courseId, []);
+			eventsByCourse.get(courseId).push(event);
+		});
+		if (eventsByCourse.size < 2) return;
+		getSetsFromCourses(Array.from(eventsByCourse.values()).map((events) => ({ events }))).forEach((set) => {
+			const linkedEventsSetId = generateId(linkedEventsParallelIdMap);
+			const linkedEventsSet = {
+				id: linkedEventsSetId,
+				type: "parallel",
+				events: set.map((e) => e.id),
+				anchor: "middle"
+			};
+			linkedEventsParallelIdMap.set(linkedEventsSetId, linkedEventsSet);
+		});
+	});
+	return {
+		settings,
+		locations: [...locationsIdMap.values()],
+		teachers: [...teachersIdMap.values()],
+		persons: [...personsIdMap.values()],
+		groups: [...groupsIdMap.values()],
+		courses: [...coursesIdMap.values()],
+		events: [...eventsIdMap.values()],
+		syllabuses: [...syllabusesIdMap.values()],
+		linkedEventsSets: [...linkedEventsParallelIdMap.values(), ...linkedEventsSequentialIdMap.values()],
+		meta: { ...warnings.length && { warnings } }
+	};
+}
+var from_default = { schedules: _schedules };
+
+//#endregion
+export { from_default as default };
+//# sourceMappingURL=index.mjs.map