@royalschedule/maps 3.3.17 → 4.0.1

package/dist/RS/to/input/settings.js

@@ -0,0 +1,17 @@
+//#region src/RS/to/input/settings.ts
+function parseSettings(settings) {
+	if (!settings.numDays) throw new Error("(RS::V3::To::parseSettings) numDays is falsy");
+	if (!settings.discretization) throw new Error("(RS::V3::To::parseSettings) discretization is falsy");
+	return {
+		numDays: settings.numDays,
+		discretization: settings.numDays,
+		dependencyIdKey: "id",
+		groupIdKey: "id",
+		collectionIdKey: "id",
+		eventIdKey: "id"
+	};
+}
+
+//#endregion
+export { parseSettings };
+//# sourceMappingURL=settings.js.map

package/dist/RS/to/input/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","names":[],"sources":["../../../../src/RS/to/input/settings.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\n\nexport function parseSettings (settings: ConnectedTypes.divisionSettings): Types.settings {\n\n  if (!settings.numDays)        throw new Error('(RS::V3::To::parseSettings) numDays is falsy');\n  if (!settings.discretization) throw new Error('(RS::V3::To::parseSettings) discretization is falsy');\n\n  return {\n    numDays:        settings.numDays,\n    discretization: settings.numDays,\n\n    dependencyIdKey: 'id',\n    groupIdKey:      'id',\n    collectionIdKey: 'id',\n    eventIdKey:      'id'\n  };\n};"],"mappings":";AAGA,SAAgB,cAAe,UAA2D;AAExF,KAAI,CAAC,SAAS,QAAgB,OAAM,IAAI,MAAM;AAC9C,KAAI,CAAC,SAAS,eAAgB,OAAM,IAAI,MAAM;AAE9C,QAAO;EACL,SAAgB,SAAS;EACzB,gBAAgB,SAAS;EAEzB,iBAAiB;EACjB,YAAiB;EACjB,iBAAiB;EACjB,YAAiB"}

package/dist/RS/to/input/teachers.js

@@ -0,0 +1,36 @@
+import { idOf } from "./util/util.js";
+import { attachLockedTimes } from "./util/attach-locked-times.js";
+import { parseDays } from "./util/parse-days.js";
+import { parseMaxWorkingHours } from "./util/parse-max-working-hours.js";
+import { parseMinimumBreakLength } from "./util/parse-minimum-break-length.js";
+import { parseIntervals } from "./util/parse-intervals.js";
+import { omitBy } from "lodash-es";
+
+//#region src/RS/to/input/teachers.ts
+function fromTeachers(teachers, settings, options) {
+	return teachers.map((teacher) => {
+		const doc = {
+			id: idOf.teacher(teacher, options),
+			group_type: "personal",
+			minimizeGaps: false,
+			minimizeDependencyAlternation: true,
+			forbidOverlappingEvents: options.oldFormat ? teacher.forbidOverlappingEvents : void 0,
+			disableDayLengthPunishment: options.oldFormat ? teacher.disableDayLengthPunishment : void 0,
+			weight: teacher.weight,
+			intervals: options.oldFormat ? parseIntervals(teacher.intervals, teacher.rootInterval ?? settings.defaultRootInterval, settings) : idOf.intervalPairReference(teacher.intervals, teacher.rootInterval, options),
+			days: parseDays(teacher.days, settings),
+			lockedTimes: attachLockedTimes(teacher.lockedTimes, options),
+			minBreakLength: parseMinimumBreakLength(teacher.minBreakLength),
+			...parseMaxWorkingHours(teacher, options)
+		};
+		if (options.meta) doc.meta = omitBy({
+			ids: teacher.ids,
+			name: teacher.displayName
+		}, (x) => x == null);
+		return omitBy(doc, (x) => x == null);
+	});
+}
+
+//#endregion
+export { fromTeachers };
+//# sourceMappingURL=teachers.js.map

package/dist/RS/to/input/teachers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teachers.js","names":["doc: Types.group"],"sources":["../../../../src/RS/to/input/teachers.ts"],"sourcesContent":["import { omitBy } from 'lodash-es';\nimport type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { parseMaxWorkingHours } from './util/parse-max-working-hours';\nimport { parseDays } from './util/parse-days';\nimport { attachLockedTimes } from './util/attach-locked-times';\nimport { parseMinimumBreakLength } from './util/parse-minimum-break-length';\nimport { idOf } from './util/util';\nimport { parseIntervals } from './util/parse-intervals';\n\nexport function fromTeachers (\n  teachers: ConnectedTypes.teacher[],\n  settings: ConnectedTypes.divisionSettings,\n  options:  Types.parsedToOptions\n): Types.group[] {\n  return teachers\n    .map(teacher => {\n      const doc: Types.group = {\n        id:                            idOf.teacher(teacher, options),\n        group_type:                    'personal',\n        minimizeGaps:                  false,\n        minimizeDependencyAlternation: true,\n        forbidOverlappingEvents:       options.oldFormat ? teacher.forbidOverlappingEvents : undefined,  // Deprecated in v3\n        disableDayLengthPunishment:    options.oldFormat ? teacher.disableDayLengthPunishment : undefined,  // Deprecated in v3\n        weight:                        teacher.weight,\n        intervals:                     options.oldFormat\n          ? parseIntervals(teacher.intervals, teacher.rootInterval ?? settings.defaultRootInterval, settings)\n          : idOf.intervalPairReference(teacher.intervals, teacher.rootInterval, options),\n        days:           parseDays                 (teacher.days, settings),\n        lockedTimes:    attachLockedTimes         (teacher.lockedTimes, options),\n        minBreakLength: parseMinimumBreakLength   (teacher.minBreakLength),\n\n        ...parseMaxWorkingHours(teacher, options),\n      };\n\n      if (options.meta) {\n        doc.meta = omitBy({\n          ids:  teacher.ids,\n          name: teacher.displayName,\n        }, x => x == null);\n      }\n\n      return omitBy(doc, x => x == null) as Types.group;\n    });\n};\n"],"mappings":";;;;;;;;;AAUA,SAAgB,aACd,UACA,UACA,SACe;AACf,QAAO,SACJ,KAAI,YAAW;EACd,MAAMA,MAAmB;GACvB,IAA+B,KAAK,QAAQ,SAAS;GACrD,YAA+B;GAC/B,cAA+B;GAC/B,+BAA+B;GAC/B,yBAA+B,QAAQ,YAAY,QAAQ,0BAA0B;GACrF,4BAA+B,QAAQ,YAAY,QAAQ,6BAA6B;GACxF,QAA+B,QAAQ;GACvC,WAA+B,QAAQ,YACnC,eAAe,QAAQ,WAAW,QAAQ,gBAAgB,SAAS,qBAAqB,YACxF,KAAK,sBAAsB,QAAQ,WAAW,QAAQ,cAAc;GACxE,MAAgB,UAA2B,QAAQ,MAAM;GACzD,aAAgB,kBAA2B,QAAQ,aAAa;GAChE,gBAAgB,wBAA2B,QAAQ;GAEnD,GAAG,qBAAqB,SAAS;;AAGnC,MAAI,QAAQ,KACV,KAAI,OAAO,OAAO;GAChB,KAAM,QAAQ;GACd,MAAM,QAAQ;MACb,MAAK,KAAK;AAGf,SAAO,OAAO,MAAK,MAAK,KAAK"}

package/dist/RS/to/input/util/attach-locked-times.js

@@ -0,0 +1,27 @@
+import { getDayIndex, getVertexId, parseDateInterval } from "../../../../core/util.js";
+import { omitBy } from "lodash-es";
+
+//#region src/RS/to/input/util/attach-locked-times.ts
+function attachLockedTimes(lockedTimes, options) {
+	return lockedTimes?.map((lockedTime) => {
+		const { start: startDate, end: endDate } = parseDateInterval(lockedTime, "locked time");
+		const length = endDate.diff(startDate, "minutes");
+		if (length < 5) throw new Error("(RS::V3::To::LockedTimes) Length of a locked time is less than 5 min");
+		const start = parseFloat(startDate.format("HH.mm"));
+		const doc = {
+			day: getDayIndex(startDate),
+			start,
+			length
+		};
+		if (options.meta) doc.meta = omitBy({
+			id: getVertexId(lockedTime, options),
+			visible: lockedTime.visible,
+			name: lockedTime.displayName
+		}, (x) => x == null);
+		return omitBy(doc, (x) => x == null);
+	});
+}
+
+//#endregion
+export { attachLockedTimes };
+//# sourceMappingURL=attach-locked-times.js.map

package/dist/RS/to/input/util/attach-locked-times.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach-locked-times.js","names":["doc: Types.lockedTime"],"sources":["../../../../../src/RS/to/input/util/attach-locked-times.ts"],"sourcesContent":["import { omitBy } from 'lodash-es';\nimport type { Types } from '../../../types';\nimport type { ConnectedTypes } from '../../../make-connected';\nimport { getDayIndex, getVertexId, parseDateInterval } from '../../../../core/util';\n\nexport function attachLockedTimes (\n  lockedTimes: ConnectedTypes.lockedTime[] | null | undefined,\n  options:     Types.parsedToOptions\n): Types.lockedTime[] | undefined {\n\n  return lockedTimes?.map(lockedTime => {\n    const { start: startDate, end: endDate } = parseDateInterval(lockedTime, 'locked time');\n\n    const length = endDate.diff(startDate, 'minutes');\n    if (length < 5) throw new Error('(RS::V3::To::LockedTimes) Length of a locked time is less than 5 min');\n\n    const start = parseFloat(startDate.format('HH.mm'));\n\n    const doc: Types.lockedTime = {\n      day:    getDayIndex(startDate),\n      start:  start,\n      length: length,\n    };\n\n    if (options.meta) {\n      doc.meta = omitBy({\n        id:      getVertexId(lockedTime, options),\n        visible: lockedTime.visible,\n        name:    lockedTime.displayName,\n      }, x => x == null);\n    }\n\n    return omitBy(doc, x => x == null) as Types.lockedTime;\n  });\n};"],"mappings":";;;;AAKA,SAAgB,kBACd,aACA,SACgC;AAEhC,QAAO,aAAa,KAAI,eAAc;EACpC,MAAM,EAAE,OAAO,WAAW,KAAK,YAAY,kBAAkB,YAAY;EAEzE,MAAM,SAAS,QAAQ,KAAK,WAAW;AACvC,MAAI,SAAS,EAAG,OAAM,IAAI,MAAM;EAEhC,MAAM,QAAQ,WAAW,UAAU,OAAO;EAE1C,MAAMA,MAAwB;GAC5B,KAAQ,YAAY;GACZ;GACA;;AAGV,MAAI,QAAQ,KACV,KAAI,OAAO,OAAO;GAChB,IAAS,YAAY,YAAY;GACjC,SAAS,WAAW;GACpB,MAAS,WAAW;MACnB,MAAK,KAAK;AAGf,SAAO,OAAO,MAAK,MAAK,KAAK"}

package/dist/RS/to/input/util/parse-days.js

@@ -0,0 +1,10 @@
+//#region src/RS/to/input/util/parse-days.ts
+function parseDays(days, settings) {
+	if (!days) return;
+	if (days.length) return days.map((x) => x.day);
+	return [...Array.from({ length: settings.numDays })].map((_, i) => i);
+}
+
+//#endregion
+export { parseDays };
+//# sourceMappingURL=parse-days.js.map

package/dist/RS/to/input/util/parse-days.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-days.js","names":[],"sources":["../../../../../src/RS/to/input/util/parse-days.ts"],"sourcesContent":["import type { ConnectedTypes } from '../../../make-connected';\n\nexport function parseDays (\n  days:    ConnectedTypes.event['days'] | ConnectedTypes.course['days'],\n  settings: ConnectedTypes.divisionSettings\n) {\n  if (!days) return;\n\n  if (days.length) return days.map(x => x.day);\n\n  // empty days means all days selected (since no days selected is prohibited)\n  return [...Array.from({ length: settings.numDays })].map((_, i) => i);\n}"],"mappings":";AAEA,SAAgB,UACd,MACA,UACA;AACA,KAAI,CAAC,KAAM;AAEX,KAAI,KAAK,OAAQ,QAAO,KAAK,KAAI,MAAK,EAAE;AAGxC,QAAO,CAAC,GAAG,MAAM,KAAK,EAAE,QAAQ,SAAS,YAAY,KAAK,GAAG,MAAM"}

package/dist/RS/to/input/util/parse-group-references.js

@@ -0,0 +1,58 @@
+import { getVertexId } from "../../../../core/util.js";
+import { makeChainable } from "../../../../common/make-chainable/index.js";
+import { idOf } from "./util.js";
+import { groupBy, uniq } from "lodash-es";
+
+//#region src/RS/to/input/util/parse-group-references.ts
+/**
+* Merges group references with their parent groups while ensuring that a group is present at
+* most once and that parent groups are prioritized as they carry no member exclusions.
+*/
+function mergeWithParentGroups(references, options) {
+	return makeChainable(references).chain((x) => x.flatMap((x$1) => [x$1, ...(x$1.to.parentGroups ?? []).map((y) => ({
+		to: y,
+		isParentGroup: true
+	}))]), (x) => groupBy(x, (x$1) => getVertexId(x$1.to, options)), (x) => Object.values(x).map((xs) => xs.find((x$1) => x$1.isParentGroup) ?? xs.at(0)).filter((x$1) => x$1 != null)).value;
+}
+/**
+* Returns the source of group, teacher, and participant references for a given item while taking into account event inheritance.
+*/
+function getSources(itemAndType) {
+	if (itemAndType.type == "lockedTime") return {
+		teachers: itemAndType.item.coalesced?.filter((x) => x.toModel == "teachers"),
+		groups: itemAndType.item.coalesced?.filter((x) => x.toModel == "groups")
+	};
+	const item = itemAndType.item;
+	const teachersSource = item.teachers ? item : "course" in item && item.course ? item.course : item;
+	const groupsAndParticipantsSource = item.groups || item.participants ? item : "course" in item && item.course ? item.course : item;
+	return {
+		teachers: teachersSource.teachers ?? void 0,
+		groups: groupsAndParticipantsSource.groups ?? void 0,
+		participants: groupsAndParticipantsSource.participants ?? void 0
+	};
+}
+/**
+* Parses group references from a course or event while carrying out event inheritance and taking into account parent groups.
+*/
+function parseGroupReferences(itemAndType, options) {
+	const sources = getSources(itemAndType);
+	if (options.oldFormat) return makeChainable([
+		...(sources.teachers ?? []).map((x) => idOf.teacher(x.to, options)),
+		...mergeWithParentGroups(sources.groups ?? [], options).flatMap((ref) => {
+			if (ref.to.species == "class") return idOf.group(ref.to, options);
+			return (ref.to.members ?? []).filter((x) => !ref.exclude?.includes(x)).map((x) => x.group ? getVertexId(x.group, options) : void 0).filter((x) => x != null);
+		}),
+		...(sources.participants ?? []).map((x) => x.to.group ? getVertexId(x.to.group, options) : void 0).filter((x) => x != null)
+	]).chain((x) => uniq(x).map((x$1) => [x$1])).value;
+	const teacherReferences = (sources.teachers ?? []).map((x) => ({ group: idOf.teacher(x.to, options) }));
+	const groupReferences = mergeWithParentGroups(sources.groups ?? [], options).map((x) => {
+		if (x.to.species != "class" || x.exclude?.length) return { individuals: idOf.groupReference(x, options) };
+		return { group: idOf.group(x.to, options) };
+	});
+	const participantReferences = sources.participants ? { individuals: sources.participants.map((x) => idOf.person(x.to, options)) } : void 0;
+	return teacherReferences.concat(groupReferences, participantReferences ? [participantReferences] : []).map((x) => [x]);
+}
+
+//#endregion
+export { parseGroupReferences };
+//# sourceMappingURL=parse-group-references.js.map

package/dist/RS/to/input/util/parse-group-references.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-group-references.js","names":["x"],"sources":["../../../../../src/RS/to/input/util/parse-group-references.ts"],"sourcesContent":["import { groupBy, uniq } from 'lodash-es';\nimport type { ConnectedTypes } from '../../../make-connected';\nimport { idOf } from './util';\nimport { getVertexId } from '../../../../core/util';\nimport type { GroupReference, PersonReference } from '../../../../core/types/common';\nimport type { Types } from '../../../types';\nimport { makeChainable } from '../../../../common/make-chainable';\n\n/**\n * Merges group references with their parent groups while ensuring that a group is present at\n * most once and that parent groups are prioritized as they carry no member exclusions.\n */\nfunction mergeWithParentGroups (\n  references: GroupReference<ConnectedTypes.group, ConnectedTypes.person>[],\n  options:    Types.parsedToOptions\n): GroupReference<ConnectedTypes.group, ConnectedTypes.person>[] {\n  return makeChainable(references)\n    .chain(\n      x => x.flatMap((x): ((typeof x) & { isParentGroup?: boolean })[] => ([\n        x, ...(x.to.parentGroups ?? []).map(y => ({ to: y, isParentGroup: true }))\n      ])),\n      x => groupBy(x, x => getVertexId(x.to, options)),\n      x => Object.values(x)\n        .map(xs => xs.find(x => x.isParentGroup) ?? xs.at(0))\n        .filter(x => x != null)\n    )\n    .value;\n}\n\ntype ItemAndType =\n  | { item: ConnectedTypes.course,     type: 'course'     }\n  | { item: ConnectedTypes.event,      type: 'event'      }\n  | { item: ConnectedTypes.lockedTime, type: 'lockedTime' };\n\ntype Source = {\n  teachers?:     PersonReference<ConnectedTypes.teacher>[];\n  groups?:       GroupReference<ConnectedTypes.group, ConnectedTypes.person>[];\n  participants?: PersonReference<ConnectedTypes.person>[];\n};\n\n/**\n * Returns the source of group, teacher, and participant references for a given item while taking into account event inheritance.\n */\nfunction getSources (itemAndType: ItemAndType): Source {\n  if (itemAndType.type == 'lockedTime') return {\n    teachers: itemAndType.item.coalesced?.filter(x => x.toModel == 'teachers'),\n    groups:   itemAndType.item.coalesced?.filter(x => x.toModel == 'groups'  )\n  };\n\n  const item = itemAndType.item;\n  const teachersSource = item.teachers\n    ? item\n    : ('course' in item && item.course ? item.course : item);\n  const groupsAndParticipantsSource = (item.groups || item.participants)\n    ? item\n    : ('course' in item && item.course ? item.course : item);\n  return {\n    teachers:     teachersSource.teachers                  ?? undefined,\n    groups:       groupsAndParticipantsSource.groups       ?? undefined,\n    participants: groupsAndParticipantsSource.participants ?? undefined\n  };\n}\n\n/**\n * Parses group references from a course or event while carrying out event inheritance and taking into account parent groups.\n */\nexport function parseGroupReferences (\n  itemAndType: ItemAndType,\n  options:     Types.parsedToOptions\n): Types.groupReference[][] {\n  const sources = getSources(itemAndType);\n\n  // if interested in the old format we care only about references to groups\n  if (options.oldFormat) {\n    return makeChainable([\n      ...(sources.teachers ?? [])\n        .map(x => idOf.teacher(x.to, options)),\n      ...mergeWithParentGroups(sources.groups ?? [], options)\n        .flatMap(ref => {\n          if (ref.to.species == 'class') return idOf.group(ref.to, options);\n\n          // if not a class fetch the remaining group member's parent group\n          return (ref.to.members ?? [])\n            .filter(x => !ref.exclude?.includes(x))\n            .map(x => x.group ? getVertexId(x.group, options) : undefined)\n            .filter(x => x != null);\n        }),\n      ...(sources.participants ?? [])\n        .map(x => x.to.group ? getVertexId(x.to.group, options) : undefined)\n        .filter(x => x != null)\n    ])\n      .chain(\n        x => uniq(x).map(x => [x])\n      )\n      .value;\n  }\n\n  const teacherReferences = (sources.teachers ?? [])\n    .map((x): Types.groupReference => ({ group: idOf.teacher(x.to, options) }));\n\n  const groupReferences = mergeWithParentGroups(sources.groups ?? [], options)\n    .map((x): Types.groupReference => {\n      if (x.to.species != 'class' || x.exclude?.length) return { individuals: idOf.groupReference(x, options) };   // use individuals set if not a plain group reference\n      return { group: idOf.group(x.to, options) };\n    });\n\n  const participantReferences = sources.participants\n    ? { individuals: sources.participants.map(x => idOf.person(x.to, options)) } as Types.groupReference\n    : undefined;\n\n  // combine all references\n  return teacherReferences\n    .concat(\n      groupReferences,\n      participantReferences ? [participantReferences] : []\n    )\n    .map(x => [x]);\n}"],"mappings":";;;;;;;;;;AAYA,SAAS,sBACP,YACA,SAC+D;AAC/D,QAAO,cAAc,YAClB,OACC,MAAK,EAAE,SAAS,QAAqD,CACnEA,KAAG,IAAIA,IAAE,GAAG,gBAAgB,IAAI,KAAI,OAAM;EAAE,IAAI;EAAG,eAAe;SAEpE,MAAK,QAAQ,IAAG,QAAK,YAAYA,IAAE,IAAI,YACvC,MAAK,OAAO,OAAO,GAChB,KAAI,OAAM,GAAG,MAAK,QAAKA,IAAE,kBAAkB,GAAG,GAAG,IACjD,QAAO,QAAKA,OAAK,OAErB;;;;;AAiBL,SAAS,WAAY,aAAkC;AACrD,KAAI,YAAY,QAAQ,aAAc,QAAO;EAC3C,UAAU,YAAY,KAAK,WAAW,QAAO,MAAK,EAAE,WAAW;EAC/D,QAAU,YAAY,KAAK,WAAW,QAAO,MAAK,EAAE,WAAW;;CAGjE,MAAM,OAAO,YAAY;CACzB,MAAM,iBAAiB,KAAK,WACxB,OACC,YAAY,QAAQ,KAAK,SAAS,KAAK,SAAS;CACrD,MAAM,8BAA+B,KAAK,UAAU,KAAK,eACrD,OACC,YAAY,QAAQ,KAAK,SAAS,KAAK,SAAS;AACrD,QAAO;EACL,UAAc,eAAe,YAA6B;EAC1D,QAAc,4BAA4B,UAAgB;EAC1D,cAAc,4BAA4B,gBAAgB;;;;;;AAO9D,SAAgB,qBACd,aACA,SAC0B;CAC1B,MAAM,UAAU,WAAW;AAG3B,KAAI,QAAQ,UACV,QAAO,cAAc;EACnB,IAAI,QAAQ,YAAY,IACrB,KAAI,MAAK,KAAK,QAAQ,EAAE,IAAI;EAC/B,GAAG,sBAAsB,QAAQ,UAAU,IAAI,SAC5C,SAAQ,QAAO;AACd,OAAI,IAAI,GAAG,WAAW,QAAS,QAAO,KAAK,MAAM,IAAI,IAAI;AAGzD,WAAQ,IAAI,GAAG,WAAW,IACvB,QAAO,MAAK,CAAC,IAAI,SAAS,SAAS,IACnC,KAAI,MAAK,EAAE,QAAQ,YAAY,EAAE,OAAO,WAAW,QACnD,QAAO,MAAK,KAAK;;EAExB,IAAI,QAAQ,gBAAgB,IACzB,KAAI,MAAK,EAAE,GAAG,QAAQ,YAAY,EAAE,GAAG,OAAO,WAAW,QACzD,QAAO,MAAK,KAAK;IAEnB,OACC,MAAK,KAAK,GAAG,KAAI,QAAK,CAACA,OAExB;CAGL,MAAM,qBAAqB,QAAQ,YAAY,IAC5C,KAAK,OAA6B,EAAE,OAAO,KAAK,QAAQ,EAAE,IAAI;CAEjE,MAAM,kBAAkB,sBAAsB,QAAQ,UAAU,IAAI,SACjE,KAAK,MAA4B;AAChC,MAAI,EAAE,GAAG,WAAW,WAAW,EAAE,SAAS,OAAQ,QAAO,EAAE,aAAa,KAAK,eAAe,GAAG;AAC/F,SAAO,EAAE,OAAO,KAAK,MAAM,EAAE,IAAI;;CAGrC,MAAM,wBAAwB,QAAQ,eAClC,EAAE,aAAa,QAAQ,aAAa,KAAI,MAAK,KAAK,OAAO,EAAE,IAAI,cAC/D;AAGJ,QAAO,kBACJ,OACC,iBACA,wBAAwB,CAAC,yBAAyB,IAEnD,KAAI,MAAK,CAAC"}

package/dist/RS/to/input/util/parse-intervals.js

@@ -0,0 +1,55 @@
+import { getDayIndex } from "../../../../core/util.js";
+import { makeChainable } from "../../../../common/make-chainable/index.js";
+import { groupBy } from "lodash-es";
+import moment from "moment";
+
+//#region src/RS/to/input/util/parse-intervals.ts
+function getDayLimits(intervals, settings) {
+	if (!intervals) {
+		const start = moment.utc(settings.dayStart, "HH:mm");
+		const end = moment.utc(settings.dayEnd, "HH:mm");
+		intervals = Array.from({ length: settings.numDays }, () => ({
+			start: start.clone(),
+			end: end.clone()
+		}));
+	} else if (intervals.length == 1) {
+		const i = intervals[0];
+		const start = moment.utc(i.start, "HH:mm");
+		const end = moment.utc(i.end, "HH:mm");
+		intervals = Array.from({ length: settings.numDays }, () => ({
+			start: start.clone(),
+			end: end.clone()
+		}));
+	} else throw new Error(`(RS::V3::To::Intervals) Intervals length ${intervals.length} does not match settings.numDays ${settings.numDays}`);
+	return intervals.map((i, day) => {
+		if (!i.start || !i.end) throw new Error(`(RS::V3::To::Intervals) Interval missing start or end for day ${day}`);
+		const start = parseFloat(moment.utc(i.start).format("HH.mm"));
+		const end = parseFloat(moment.utc(i.end).format("HH.mm"));
+		return {
+			beg: start,
+			end
+		};
+	});
+}
+/**
+* @deprecated The old way of parsing intervals
+*/
+function parseIntervals(intervals, rootInterval, settings) {
+	if (intervals && !rootInterval) return getDayLimits(intervals, settings).map((i) => [i]);
+	if (rootInterval) {
+		const dayLimits = getDayLimits(intervals, settings);
+		return makeChainable(rootInterval.intervals).chain((x) => groupBy(x, (x$1) => getDayIndex(x$1.start)), (x) => Object.entries(x).map(([day, xs]) => {
+			const limit = dayLimits.at(parseInt(day));
+			if (!limit) throw new Error(`(RS::V3::To::Intervals) Day ${day} not found in dayStartAndEnds`);
+			return xs.map((x$1) => ({
+				beg: parseFloat(moment.utc(x$1.start).format("HH.mm")),
+				end: parseFloat(moment.utc(x$1.end).format("HH.mm")),
+				binary: true
+			})).filter((x$1) => x$1.beg >= limit.beg && x$1.end <= limit.end);
+		})).value;
+	}
+}
+
+//#endregion
+export { parseIntervals };
+//# sourceMappingURL=parse-intervals.js.map

package/dist/RS/to/input/util/parse-intervals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-intervals.js","names":["x"],"sources":["../../../../../src/RS/to/input/util/parse-intervals.ts"],"sourcesContent":["import moment from 'moment';\nimport { groupBy } from 'lodash-es';\nimport type { ConnectedTypes } from '../../../make-connected';\nimport type { AllowedInterval } from '../../../../core/types/common/intervals';\nimport { getDayIndex } from '../../../../core/util';\nimport type { Types } from '../../../types';\nimport { makeChainable } from '../../../../common/make-chainable';\n\nfunction getDayLimits (\n  intervals: AllowedInterval[] | undefined,\n  settings: ConnectedTypes.divisionSettings\n): { beg: number, end: number }[] {\n  // remove short-hand notation (a single interval for all days)\n  if (!intervals) {\n    const start = moment.utc(settings.dayStart, 'HH:mm');\n    const end   = moment.utc(settings.dayEnd,   'HH:mm');\n    intervals = Array.from({ length: settings.numDays }, () => ({ start: start.clone(), end: end.clone() }));\n  }\n  else if (intervals.length == 1) {\n    const i = intervals[0];\n    const start = moment.utc(i.start, 'HH:mm');\n    const end   = moment.utc(i.end,   'HH:mm');\n    intervals = Array.from({ length: settings.numDays }, () => ({ start: start.clone(), end: end.clone() }));\n  } else {\n    throw new Error(`(RS::V3::To::Intervals) Intervals length ${intervals.length} does not match settings.numDays ${settings.numDays}`);\n  }\n\n  // the day start and end times of each day\n  return intervals.map((i, day: number) => {\n    if (!i.start || !i.end) throw new Error(`(RS::V3::To::Intervals) Interval missing start or end for day ${day}`);\n    const start = parseFloat(moment.utc(i.start).format('HH.mm'));\n    const end   = parseFloat(moment.utc(i.end  ).format('HH.mm'));\n    return { beg: start, end: end };\n  });\n}\n\n\n/**\n * @deprecated The old way of parsing intervals\n */\nexport function parseIntervals (\n  intervals:     AllowedInterval[]           | undefined,\n  rootInterval:  ConnectedTypes.rootInterval | undefined,\n  settings:      ConnectedTypes.divisionSettings\n): Types.interval[][] | undefined {\n  // if only intervals are provided\n  if (intervals && !rootInterval) return getDayLimits(intervals, settings).map(i => [i]);\n\n  // if root intervals are present\n  if (rootInterval) {\n    const dayLimits = getDayLimits(intervals, settings);\n    return makeChainable(rootInterval.intervals)\n      .chain(\n        x => groupBy(x, x => getDayIndex(x.start)),\n        x => Object.entries(x)\n          .map(([day, xs]) => {\n            const limit = dayLimits.at(parseInt(day));\n            if (!limit) throw new Error(`(RS::V3::To::Intervals) Day ${day} not found in dayStartAndEnds`);\n\n            // remove all block intervals that lay outside the day start and end\n            return xs\n              .map(x => ({\n                beg:    parseFloat(moment.utc(x.start).format('HH.mm')),\n                end:    parseFloat(moment.utc(x.end  ).format('HH.mm')),\n                binary: true\n              } satisfies Types.interval))\n              .filter(x => x.beg >= limit.beg && x.end <= limit.end);\n          })\n      )\n      .value;\n  }\n\n  // only remaining case here is \"!intervals && !rootInterval\"\n  return;\n};\n"],"mappings":";;;;;;AAQA,SAAS,aACP,WACA,UACgC;AAEhC,KAAI,CAAC,WAAW;EACd,MAAM,QAAQ,OAAO,IAAI,SAAS,UAAU;EAC5C,MAAM,MAAQ,OAAO,IAAI,SAAS,QAAU;AAC5C,cAAY,MAAM,KAAK,EAAE,QAAQ,SAAS,kBAAkB;GAAE,OAAO,MAAM;GAAS,KAAK,IAAI;;YAEtF,UAAU,UAAU,GAAG;EAC9B,MAAM,IAAI,UAAU;EACpB,MAAM,QAAQ,OAAO,IAAI,EAAE,OAAO;EAClC,MAAM,MAAQ,OAAO,IAAI,EAAE,KAAO;AAClC,cAAY,MAAM,KAAK,EAAE,QAAQ,SAAS,kBAAkB;GAAE,OAAO,MAAM;GAAS,KAAK,IAAI;;OAE7F,OAAM,IAAI,MAAM,4CAA4C,UAAU,OAAO,mCAAmC,SAAS;AAI3H,QAAO,UAAU,KAAK,GAAG,QAAgB;AACvC,MAAI,CAAC,EAAE,SAAS,CAAC,EAAE,IAAK,OAAM,IAAI,MAAM,iEAAiE;EACzG,MAAM,QAAQ,WAAW,OAAO,IAAI,EAAE,OAAO,OAAO;EACpD,MAAM,MAAQ,WAAW,OAAO,IAAI,EAAE,KAAO,OAAO;AACpD,SAAO;GAAE,KAAK;GAAY;;;;;;;AAQ9B,SAAgB,eACd,WACA,cACA,UACgC;AAEhC,KAAI,aAAa,CAAC,aAAc,QAAO,aAAa,WAAW,UAAU,KAAI,MAAK,CAAC;AAGnF,KAAI,cAAc;EAChB,MAAM,YAAY,aAAa,WAAW;AAC1C,SAAO,cAAc,aAAa,WAC/B,OACC,MAAK,QAAQ,IAAG,QAAK,YAAYA,IAAE,UACnC,MAAK,OAAO,QAAQ,GACjB,KAAK,CAAC,KAAK,QAAQ;GAClB,MAAM,QAAQ,UAAU,GAAG,SAAS;AACpC,OAAI,CAAC,MAAO,OAAM,IAAI,MAAM,+BAA+B,IAAI;AAG/D,UAAO,GACJ,KAAI,SAAM;IACT,KAAQ,WAAW,OAAO,IAAIA,IAAE,OAAO,OAAO;IAC9C,KAAQ,WAAW,OAAO,IAAIA,IAAE,KAAO,OAAO;IAC9C,QAAQ;OAET,QAAO,QAAKA,IAAE,OAAO,MAAM,OAAOA,IAAE,OAAO,MAAM;MAGzD"}

package/dist/RS/to/input/util/parse-location-references.js

@@ -0,0 +1,31 @@
+import { getVertexId } from "../../../../core/util.js";
+import { makeChainable } from "../../../../common/make-chainable/index.js";
+import { groupBy } from "lodash-es";
+
+//#region src/RS/to/input/util/parse-location-references.ts
+function parseLocationReferences(references, options) {
+	if (!references) return;
+	return makeChainable(references).chain((x) => x.map(({ locations, groupIndex, rank }) => ({
+		dependency: getVertexId(locations[0], options),
+		rank,
+		groupIndex
+	})).filter((x$1) => {
+		const includedLocations = options.partialScheduleOptions?.includedLocations;
+		if (!includedLocations) return true;
+		return includedLocations.has(x$1.dependency);
+	}), (x) => groupBy(x, (x$1) => x$1.groupIndex), (x) => Object.values(x).map((xs) => xs.map((x$1) => ({
+		dependency: x$1.dependency,
+		rank: x$1.rank
+	})))).value;
+}
+function parseSelectedLocations(event, options) {
+	const locationsRef = event.locations ?? event.course?.locations;
+	const dependencies = parseLocationReferences(locationsRef, options);
+	const inLocations = event.inLocations ?? [];
+	if (inLocations.length === dependencies?.length) return inLocations.map((x) => x ? getVertexId(x, options) : null);
+	return inLocations.map((x) => x ? getVertexId(x, options) : null).concat(Array.from({ length: Math.max((dependencies?.length ?? 0) - inLocations.length, 0) }).map(() => null));
+}
+
+//#endregion
+export { parseLocationReferences, parseSelectedLocations };
+//# sourceMappingURL=parse-location-references.js.map

package/dist/RS/to/input/util/parse-location-references.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-location-references.js","names":["x"],"sources":["../../../../../src/RS/to/input/util/parse-location-references.ts"],"sourcesContent":["import { groupBy } from 'lodash-es';\nimport type { ConnectedTypes } from '../../../make-connected';\nimport type { Types } from '../../../types';\nimport { getVertexId } from '../../../../core/util';\nimport type { AvailableLocation } from '../../../../core/types/common';\nimport { makeChainable } from '../../../../common/make-chainable';\n\nexport function parseLocationReferences (\n  references: AvailableLocation<ConnectedTypes.location>[] | null | undefined,\n  options:    Types.parsedToOptions\n) {\n  if (!references) return;\n\n  return makeChainable(references)\n    .chain(\n      x => x\n        .map(({ locations, groupIndex, rank }) => ({\n          dependency: getVertexId(locations[0], options),\n          rank:       rank,\n          groupIndex: groupIndex\n        }))\n        .filter(x => {\n          // filter location references based on partial schedule options\n          const includedLocations = options.partialScheduleOptions?.includedLocations;\n          if (!includedLocations) return true;\n          return includedLocations.has(x.dependency);\n        }),\n      x => groupBy(x, x => x.groupIndex),\n      x => Object.values(x)\n        .map(xs => xs.map(x => ({\n          dependency: x.dependency,\n          rank:       x.rank,\n        }) as Types.availableDependency))\n    )\n    .value;\n}\n\nexport function parseSelectedLocations (event: ConnectedTypes.event, options: Types.parsedToOptions) {\n\n  const locationsRef = event.locations ?? event.course?.locations;\n  const dependencies = parseLocationReferences(locationsRef, options);\n  const inLocations  = event.inLocations ?? [];\n\n  // simply use inLocations if they match the number of dependencies\n  if (inLocations.length === dependencies?.length) {\n    return inLocations.map(x =>  x ? getVertexId(x, options) : null);\n  }\n\n  // otherwise, fill inLocations with nulls to match the number of dependencies\n  return inLocations\n    .map(x =>  x ? getVertexId(x, options) : null)\n    .concat(Array\n      .from({ length: Math.max((dependencies?.length ?? 0) - inLocations.length, 0) })\n      .map(() => null as string | null)\n    );\n}"],"mappings":";;;;;AAOA,SAAgB,wBACd,YACA,SACA;AACA,KAAI,CAAC,WAAY;AAEjB,QAAO,cAAc,YAClB,OACC,MAAK,EACF,KAAK,EAAE,WAAW,YAAY,YAAY;EACzC,YAAY,YAAY,UAAU,IAAI;EAC1B;EACA;KAEb,QAAO,QAAK;EAEX,MAAM,oBAAoB,QAAQ,wBAAwB;AAC1D,MAAI,CAAC,kBAAmB,QAAO;AAC/B,SAAO,kBAAkB,IAAIA,IAAE;MAEnC,MAAK,QAAQ,IAAG,QAAKA,IAAE,cACvB,MAAK,OAAO,OAAO,GAChB,KAAI,OAAM,GAAG,KAAI,SAAM;EACtB,YAAYA,IAAE;EACd,MAAYA,IAAE;OAGnB;;AAGL,SAAgB,uBAAwB,OAA6B,SAAgC;CAEnG,MAAM,eAAe,MAAM,aAAa,MAAM,QAAQ;CACtD,MAAM,eAAe,wBAAwB,cAAc;CAC3D,MAAM,cAAe,MAAM,eAAe;AAG1C,KAAI,YAAY,WAAW,cAAc,OACvC,QAAO,YAAY,KAAI,MAAM,IAAI,YAAY,GAAG,WAAW;AAI7D,QAAO,YACJ,KAAI,MAAM,IAAI,YAAY,GAAG,WAAW,MACxC,OAAO,MACL,KAAK,EAAE,QAAQ,KAAK,KAAK,cAAc,UAAU,KAAK,YAAY,QAAQ,MAC1E,UAAU"}

package/dist/RS/to/input/util/parse-max-working-hours.js

@@ -0,0 +1,17 @@
+import { min2hrs } from "./util.js";
+
+//#region src/RS/to/input/util/parse-max-working-hours.ts
+function parseMaxWorkingHours(group, options) {
+	if (options.useMaximumScheduleSpan && group.maximumScheduleSpan) return {
+		maxNumWorkingHours: min2hrs(group.maximumScheduleSpan.daily) ?? false,
+		maxNumDailyWorkingHours: min2hrs(group.maximumScheduleSpan.daily) ?? false
+	};
+	if (!options.useMaximumScheduleSpan) return {
+		..."maxNumWorkingHours" in group && { maxNumWorkingHours: group.maxNumWorkingHours },
+		..."maxNumDailyWorkingHours" in group && { maxNumDailyWorkingHours: group.maxNumDailyWorkingHours }
+	};
+}
+
+//#endregion
+export { parseMaxWorkingHours };
+//# sourceMappingURL=parse-max-working-hours.js.map

package/dist/RS/to/input/util/parse-max-working-hours.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-max-working-hours.js","names":[],"sources":["../../../../../src/RS/to/input/util/parse-max-working-hours.ts"],"sourcesContent":["import type { ConnectedTypes } from '../../../make-connected';\nimport type { Types } from '../../../types';\nimport { min2hrs } from './util';\n\nexport function parseMaxWorkingHours (\n  group:   ConnectedTypes.group | ConnectedTypes.teacher,\n  options: Types.parsedToOptions\n): Pick<Types.group, 'maxNumWorkingHours' | 'maxNumDailyWorkingHours'> | undefined {\n  // new format\n  if (options.useMaximumScheduleSpan && group.maximumScheduleSpan) {\n    return {\n      maxNumWorkingHours:      min2hrs(group.maximumScheduleSpan.daily) ?? false,\n      maxNumDailyWorkingHours: min2hrs(group.maximumScheduleSpan.daily) ?? false,\n    };\n  }\n\n  // old format, to become deprecated\n  if (!options.useMaximumScheduleSpan) {\n    return {\n      ...'maxNumWorkingHours'      in group && { maxNumWorkingHours:      group.maxNumWorkingHours },\n      ...'maxNumDailyWorkingHours' in group && { maxNumDailyWorkingHours: group.maxNumDailyWorkingHours },\n    };\n  }\n\n  return;\n}\n"],"mappings":";;;AAIA,SAAgB,qBACd,OACA,SACiF;AAEjF,KAAI,QAAQ,0BAA0B,MAAM,oBAC1C,QAAO;EACL,oBAAyB,QAAQ,MAAM,oBAAoB,UAAU;EACrE,yBAAyB,QAAQ,MAAM,oBAAoB,UAAU;;AAKzE,KAAI,CAAC,QAAQ,uBACX,QAAO;EACL,GAAG,wBAA6B,SAAS,EAAE,oBAAyB,MAAM;EAC1E,GAAG,6BAA6B,SAAS,EAAE,yBAAyB,MAAM"}

package/dist/RS/to/input/util/parse-minimum-break-length.js

@@ -0,0 +1,19 @@
+//#region src/RS/to/input/util/parse-minimum-break-length.ts
+function parseMinimumBreakLength(value) {
+	if (value == null) return;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value;
+	if (Array.isArray(value)) {
+		if (value.length !== 2) throw new Error("(RS::V3::To::BreakLengths) BreakLength array must have exactly two elements");
+		const [bef, aft] = value;
+		return {
+			bef,
+			aft
+		};
+	}
+	throw new Error("(RS::V3::To::BreakLengths) BreakLength is neither boolean, number or number array");
+}
+
+//#endregion
+export { parseMinimumBreakLength };
+//# sourceMappingURL=parse-minimum-break-length.js.map

package/dist/RS/to/input/util/parse-minimum-break-length.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-minimum-break-length.js","names":[],"sources":["../../../../../src/RS/to/input/util/parse-minimum-break-length.ts"],"sourcesContent":["import type { CoreTypes } from '../../../../core';\nimport type { Types } from '../../../types';\n\nexport function parseMinimumBreakLength (value: CoreTypes.breakLength | null | undefined): Types.breakLength | undefined {\n  if (value == null) return;\n\n  if (typeof value === 'boolean') return value;\n  if (typeof value === 'number') return value;\n\n  if (Array.isArray(value)) {\n    if (value.length !== 2) throw new Error('(RS::V3::To::BreakLengths) BreakLength array must have exactly two elements');\n    const [bef, aft] = value;\n    return { bef, aft };\n  }\n\n  throw new Error('(RS::V3::To::BreakLengths) BreakLength is neither boolean, number or number array');\n};\n"],"mappings":";AAGA,SAAgB,wBAAyB,OAAgF;AACvH,KAAI,SAAS,KAAM;AAEnB,KAAI,OAAO,UAAU,UAAW,QAAO;AACvC,KAAI,OAAO,UAAU,SAAU,QAAO;AAEtC,KAAI,MAAM,QAAQ,QAAQ;AACxB,MAAI,MAAM,WAAW,EAAG,OAAM,IAAI,MAAM;EACxC,MAAM,CAAC,KAAK,OAAO;AACnB,SAAO;GAAE;GAAK;;;AAGhB,OAAM,IAAI,MAAM"}

package/dist/RS/to/input/util/util.js

@@ -0,0 +1,61 @@
+import { getVertexId } from "../../../../core/util.js";
+
+//#region src/RS/to/input/util/util.ts
+function min2hrs(min) {
+	return min ? min / 60 : void 0;
+}
+/**
+* Converts a time string in the format "HH:MM" to a float representation, e.g., "12:30" becomes 12.3.
+*/
+function toTimeFloat(str) {
+	return parseFloat(str.replace(":", "."));
+}
+function getPeriodIndex(period, periodsMap, options) {
+	if (!period) return;
+	const id = getVertexId(period, options);
+	const periodIndex = periodsMap.get(id);
+	if (periodIndex === void 0) throw new Error(`(RS::V3::To::getPeriodIndex) Period "${id}" is not in periodsMap`);
+	return periodIndex;
+}
+const COLLECTION_ID = {
+	persons: "persons",
+	groups: "groups",
+	teachers: "teachers",
+	events: "events",
+	lockedTimes: "lockedtimes"
+};
+let idOf;
+(function(_idOf) {
+	function person(person$1, options) {
+		return `${COLLECTION_ID.persons}.${getVertexId(person$1, options)}`;
+	}
+	_idOf.person = person;
+	function group(group$1, options) {
+		return `${COLLECTION_ID.groups}.${getVertexId(group$1, options)}`;
+	}
+	_idOf.group = group;
+	function teacher(teacher$1, options) {
+		return `${COLLECTION_ID.teachers}.${getVertexId(teacher$1, options)}`;
+	}
+	_idOf.teacher = teacher;
+	function event(event$1, options) {
+		return `${COLLECTION_ID.events}.${getVertexId(event$1, options)}`;
+	}
+	_idOf.event = event;
+	function lockedTime(lockedTime$1, options) {
+		return `${COLLECTION_ID.lockedTimes}.${getVertexId(lockedTime$1, options)}`;
+	}
+	_idOf.lockedTime = lockedTime;
+	function groupReference(group$1, options) {
+		return `${COLLECTION_ID.groups}.${getVertexId(group$1.to, options)}` + (group$1.exclude?.length ? ".exclude." + group$1.exclude.map((x) => getVertexId(x, options)).sort().join(".") : "");
+	}
+	_idOf.groupReference = groupReference;
+	function intervalPairReference(interval, rootInterval, options) {
+		return (rootInterval ? getVertexId(rootInterval, options) + "&" : "") + JSON.stringify(interval);
+	}
+	_idOf.intervalPairReference = intervalPairReference;
+})(idOf || (idOf = {}));
+
+//#endregion
+export { COLLECTION_ID, getPeriodIndex, idOf, min2hrs, toTimeFloat };
+//# sourceMappingURL=util.js.map

package/dist/RS/to/input/util/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","names":["person","group","teacher","event","lockedTime"],"sources":["../../../../../src/RS/to/input/util/util.ts"],"sourcesContent":["import type { ConnectedTypes } from '../../../make-connected';\nimport type { Types } from '../../../types';\nimport type { Collection, GroupReference } from '../../../../core/types/common';\nimport { getVertexId } from '../../../../core/util';\nimport type { AllowedInterval } from '../../../../core/types/common/intervals';\n\nexport function min2hrs (min: number | undefined | null) {\n  return min ? min / 60 : undefined;\n}\n\n/**\n * Converts a time string in the format \"HH:MM\" to a float representation, e.g., \"12:30\" becomes 12.3.\n */\nexport function toTimeFloat (str: string) {\n  return parseFloat(str.replace(':', '.'));\n}\n\nexport function getPeriodIndex (\n  period:     ConnectedTypes.period | undefined | null,\n  periodsMap: Map<string | undefined, number>,\n  options:    Types.parsedToOptions\n): number | undefined {\n  if (!period) return;\n  const id = getVertexId(period, options);\n  const periodIndex = periodsMap.get(id);\n  if (periodIndex === undefined) throw new Error(`(RS::V3::To::getPeriodIndex) Period \"${id}\" is not in periodsMap`);\n  return periodIndex;\n}\n\nexport const COLLECTION_ID = {\n  persons:     'persons',\n  groups:      'groups',\n  teachers:    'teachers',\n  events:      'events',\n  lockedTimes: 'lockedtimes',\n} satisfies Partial<Record<Collection, string>>;\n\n/**\n * returns a combined id for the vertex or edge by combining the type(s) and id(s).\n */\nexport namespace idOf {\n  /** `persons.id` */\n  export function person (\n    person:  ConnectedTypes.person | string,\n    options: Types.parsedToOptions\n  ): string {\n    return `${COLLECTION_ID.persons}.${ getVertexId(person, options) }`;\n  }\n\n  /** `groups.id` */\n  export function group (\n    group:   ConnectedTypes.group,\n    options: Types.parsedToOptions\n  ): string {\n    return `${COLLECTION_ID.groups}.${ getVertexId(group, options) }`;\n  }\n\n  /** `teachers.id` */\n  export function teacher (\n    teacher: ConnectedTypes.teacher,\n    options: Types.parsedToOptions\n  ): string {\n    return `${COLLECTION_ID.teachers}.${ getVertexId(teacher, options) }`;\n  }\n\n  /** `events.id` */\n  export function event (\n    event:   ConnectedTypes.event,\n    options: Types.parsedToOptions\n  ): string {\n    return `${COLLECTION_ID.events}.${ getVertexId(event, options) }`;\n  }\n\n  /** `lockedtimes.id` */\n  export function lockedTime (\n    lockedTime: ConnectedTypes.lockedTime,\n    options:    Types.parsedToOptions\n  ): string {\n    return `${COLLECTION_ID.lockedTimes}.${ getVertexId(lockedTime, options) }`;\n  }\n\n  /** `groups.id<.exclude.id1.id2...>` */\n  export function groupReference (\n    group:   GroupReference<ConnectedTypes.group, ConnectedTypes.person>,\n    options: Types.parsedToOptions\n  ): string {\n    return `${COLLECTION_ID.groups}.${ getVertexId(group.to, options) }`\n      + (group.exclude?.length\n        ? '.exclude.' + group.exclude\n          .map(x => getVertexId(x, options))\n          .sort()\n          .join('.')\n        : '');\n  }\n\n  /** `<rootIntervalsId&>JSON.stringify(intervals)>` */\n  export function intervalPairReference (\n    interval:     AllowedInterval[]           | undefined,\n    rootInterval: ConnectedTypes.rootInterval | undefined,\n    options:      Types.parsedToOptions\n  ): string {\n    return (rootInterval ? getVertexId(rootInterval, options) + '&' : '') + JSON.stringify(interval);\n  }\n}\n"],"mappings":";;;AAMA,SAAgB,QAAS,KAAgC;AACvD,QAAO,MAAM,MAAM,KAAK;;;;;AAM1B,SAAgB,YAAa,KAAa;AACxC,QAAO,WAAW,IAAI,QAAQ,KAAK;;AAGrC,SAAgB,eACd,QACA,YACA,SACoB;AACpB,KAAI,CAAC,OAAQ;CACb,MAAM,KAAK,YAAY,QAAQ;CAC/B,MAAM,cAAc,WAAW,IAAI;AACnC,KAAI,gBAAgB,OAAW,OAAM,IAAI,MAAM,wCAAwC,GAAG;AAC1F,QAAO;;AAGT,MAAa,gBAAgB;CAC3B,SAAa;CACb,QAAa;CACb,UAAa;CACb,QAAa;CACb,aAAa;;;;CAQN,SAAS,OACd,UACA,SACQ;AACR,SAAO,GAAG,cAAc,QAAQ,GAAI,YAAYA,UAAQ;;;CAInD,SAAS,MACd,SACA,SACQ;AACR,SAAO,GAAG,cAAc,OAAO,GAAI,YAAYC,SAAO;;;CAIjD,SAAS,QACd,WACA,SACQ;AACR,SAAO,GAAG,cAAc,SAAS,GAAI,YAAYC,WAAS;;;CAIrD,SAAS,MACd,SACA,SACQ;AACR,SAAO,GAAG,cAAc,OAAO,GAAI,YAAYC,SAAO;;;CAIjD,SAAS,WACd,cACA,SACQ;AACR,SAAO,GAAG,cAAc,YAAY,GAAI,YAAYC,cAAY;;;CAI3D,SAAS,eACd,SACA,SACQ;AACR,SAAO,GAAG,cAAc,OAAO,GAAI,YAAYH,QAAM,IAAI,cACpDA,QAAM,SAAS,SACd,cAAcA,QAAM,QACnB,KAAI,MAAK,YAAY,GAAG,UACxB,OACA,KAAK,OACN;;;CAID,SAAS,sBACd,UACA,cACA,SACQ;AACR,UAAQ,eAAe,YAAY,cAAc,WAAW,MAAM,MAAM,KAAK,UAAU"}

package/dist/RS/to/schedules.d.ts

@@ -0,0 +1,7 @@
+import { Types } from "../types/index.js";
+
+//#region src/RS/to/schedules.d.ts
+declare function schedules(data: Types.toInput, _options?: Types.toOptions): Types.toOutput;
+//#endregion
+export { schedules };
+//# sourceMappingURL=schedules.d.ts.map

package/dist/RS/to/schedules.js

@@ -0,0 +1,40 @@
+import { CoreMap } from "../../core/index.js";
+import { parseInput } from "./input/input.js";
+import { makeConnected } from "../make-connected.js";
+import { initialConfiguration } from "./initial-configuration.js";
+import { pick } from "lodash-es";
+
+//#region src/RS/to/schedules.ts
+function schedules(data, _options = {}) {
+	const options = (() => {
+		const x = _options.partialScheduleOptions;
+		const partialScheduleOptions = x ? {
+			includedEvents: x.includedEvents ? new Set(x.includedEvents) : void 0,
+			includedLocations: x.includedLocations ? new Set(x.includedLocations) : void 0,
+			omittedEventsHandling: x.omittedEventsHandling
+		} : void 0;
+		return {
+			..._options,
+			partialScheduleOptions
+		};
+	})();
+	if (options.partialScheduleOptions?.includedEvents?.size) options.partialScheduleOptions.includedEvents = new Set([...options.partialScheduleOptions.includedEvents].map((x) => {
+		if (x.startsWith("events.") || x.startsWith("lockedTimes.")) return x;
+		return `events.${x}`;
+	}));
+	const connectedData = makeConnected(data);
+	return {
+		meta: {
+			structure: "RS/algorithm-3.0.0",
+			division: pick(data.division, "displayName", "start", "end")
+		},
+		algorithmParameters: { weights: options.algorithmWeightParameters },
+		input: parseInput(connectedData, options),
+		...options.appendCoreData && { coreData: CoreMap.to.schedules(data) },
+		...options.appendOutput && { output: initialConfiguration(connectedData.events, connectedData.lockedTimes, options) }
+	};
+}
+
+//#endregion
+export { schedules };
+//# sourceMappingURL=schedules.js.map

package/dist/RS/to/schedules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedules.js","names":["partialScheduleOptions: Types.parsedToOptions['partialScheduleOptions']"],"sources":["../../../src/RS/to/schedules.ts"],"sourcesContent":["import { pick } from 'lodash-es';\nimport { parseInput } from './input/input';\nimport { makeConnected } from '../make-connected';\nimport { initialConfiguration } from './initial-configuration';\nimport type { Types } from '../types';\nimport { CoreMap } from '../../core';\n\nexport function schedules (\n  data:     Types.toInput,\n  _options: Types.toOptions = {}\n): Types.toOutput {\n  ////\n  //// parse the options\n  ////\n  const options = ((): Types.parsedToOptions => {\n    const x = _options.partialScheduleOptions;\n    const partialScheduleOptions: Types.parsedToOptions['partialScheduleOptions'] = x\n      ? {\n        includedEvents:        x.includedEvents    ? new Set(x.includedEvents)    : undefined,\n        includedLocations:     x.includedLocations ? new Set(x.includedLocations) : undefined,\n        omittedEventsHandling: x.omittedEventsHandling\n      }\n      : undefined;\n\n    return { ..._options, partialScheduleOptions };\n  })();\n\n  ////\n  //// for backward compatibility: add default collection to included events set\n  ////\n  if (options.partialScheduleOptions?.includedEvents?.size) {\n    options.partialScheduleOptions.includedEvents = new Set(\n      [...options.partialScheduleOptions.includedEvents]\n        .map(x => {\n          // should start with 'events.' or 'lockedTimes.' prefix\n          if (x.startsWith('events.') || x.startsWith('lockedTimes.')) return x;\n          return `events.${x}`;\n        })\n    );\n  }\n\n\n  // we will work only with connected schedule data\n  const connectedData = makeConnected(data);\n\n  return {\n    meta: {\n      structure: 'RS/algorithm-3.0.0' satisfies Types.structure,\n      division:  pick(data.division, 'displayName', 'start', 'end'),\n    },\n    algorithmParameters: {\n      weights: options.algorithmWeightParameters,\n    },\n    input: parseInput(connectedData, options),\n    ...options.appendCoreData && { coreData: CoreMap.to.schedules(data) },\n    ...options.appendOutput   && { output: initialConfiguration(connectedData.events, connectedData.lockedTimes, options) },\n  };\n};"],"mappings":";;;;;;;AAOA,SAAgB,UACd,MACA,WAA4B,IACZ;CAIhB,MAAM,iBAAwC;EAC5C,MAAM,IAAI,SAAS;EACnB,MAAMA,yBAA0E,IAC5E;GACA,gBAAuB,EAAE,iBAAoB,IAAI,IAAI,EAAE,kBAAqB;GAC5E,mBAAuB,EAAE,oBAAoB,IAAI,IAAI,EAAE,qBAAqB;GAC5E,uBAAuB,EAAE;MAEzB;AAEJ,SAAO;GAAE,GAAG;GAAU;;;AAMxB,KAAI,QAAQ,wBAAwB,gBAAgB,KAClD,SAAQ,uBAAuB,iBAAiB,IAAI,IAClD,CAAC,GAAG,QAAQ,uBAAuB,gBAChC,KAAI,MAAK;AAER,MAAI,EAAE,WAAW,cAAc,EAAE,WAAW,gBAAiB,QAAO;AACpE,SAAO,UAAU;;CAOzB,MAAM,gBAAgB,cAAc;AAEpC,QAAO;EACL,MAAM;GACJ,WAAW;GACX,UAAW,KAAK,KAAK,UAAU,eAAe,SAAS;;EAEzD,qBAAqB,EACnB,SAAS,QAAQ;EAEnB,OAAO,WAAW,eAAe;EACjC,GAAG,QAAQ,kBAAkB,EAAE,UAAU,QAAQ,GAAG,UAAU;EAC9D,GAAG,QAAQ,gBAAkB,EAAE,QAAQ,qBAAqB,cAAc,QAAQ,cAAc,aAAa"}

package/dist/RS/{v3/types → types}/algorithm-parameters.d.ts

@@ -1,4 +1,4 @@
-//#region src/RS/v3/types/algorithm-parameters.d.ts
+//#region src/RS/types/algorithm-parameters.d.ts
 type ParameterName = 'overlap' | 'doubleBooking' | 'timeFrame' | 'breakLength' | 'clustering' | 'dailyOvertime' | 'position' | 'gap' | 'dependencyAlternation' | 'overtime' | 'dependencyRank' | 'dayRank' | 'groupRank';
 type AlgorithmWeightParameters = Record<ParameterName, number | false>;
 //#endregion

package/dist/RS/types/collections.d.ts

@@ -0,0 +1,26 @@
+import { Types } from "./index.js";
+
+//#region src/RS/types/collections.d.ts
+interface Collection {
+  id: string;
+  events: (Types.event | number)[];
+  name?: string;
+  subject?: string;
+  color?: string;
+  potentialCenter?: number;
+  density?: number;
+  weight?: number;
+  minBreakLength?: Types.breakLength;
+  lockedTimes?: Types.lockedTime[];
+  intervals?: string | Types.interval[][];
+  days?: (Types.day | number)[];
+  groups?: Types.groupReference[][];
+  dependencies?: (Types.availableDependency[] | Types.availableDependency)[];
+  period?: number;
+  maxEventLengthVariance?: number;
+  distributionKey?: string | string[];
+  meta?: Record<string, unknown>;
+}
+//#endregion
+export { Collection };
+//# sourceMappingURL=collections.d.ts.map

package/dist/RS/types/configurations.d.ts

@@ -0,0 +1,10 @@
+import { Types } from "./index.js";
+
+//#region src/RS/types/configurations.d.ts
+type Configuration = {
+  score?: [number, number, number, number];
+  events: Types.eventConfiguration[];
+};
+//#endregion
+export { Configuration };
+//# sourceMappingURL=configurations.d.ts.map

package/dist/RS/{v3/types → types}/default.d.ts

@@ -1,12 +1,11 @@
-import { Interval } from "./intervals.js";
-import { BreakLength } from "./break-lengths.js";
+import { Types } from "./index.js";
 
-//#region src/RS/v3/types/default.d.ts
+//#region src/RS/types/default.d.ts
 interface Default {
-  intervals: Interval[][];
+  intervals: string | Types.interval[][];
   dependencyMinBreakLength: number;
   groupMinBreakLength: number;
-  eventMinBreakLength: BreakLength;
+  eventMinBreakLength: Types.breakLength;
   potentialCenter: number;
   eventDensity: number;
   maxEventLengthVariance: number;

package/dist/RS/types/dependencies.d.ts

@@ -0,0 +1,16 @@
+import { Types } from "./index.js";
+
+//#region src/RS/types/dependencies.d.ts
+interface Dependency {
+  id?: string;
+  minBreakLength?: number;
+  name?: string;
+  area?: string;
+  days?: (Types.day | number)[];
+  intervals?: string | Types.interval[][];
+  lockedTimes?: Types.lockedTime[];
+  meta?: Record<string, unknown>;
+}
+//#endregion
+export { Dependency };
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/RS/types/event-configuration.d.ts

@@ -0,0 +1,20 @@
+//#region src/RS/types/event-configuration.d.ts
+interface EventConfiguration {
+  id: string;
+  start: number;
+  end: number;
+  day: number;
+  collection?: string;
+  dependencies?: string[];
+  /**
+   * @deprecated Currently no need to use this as groups are fixed
+   */
+  groups?: ({
+    groups: string[];
+  } | {
+    individuals: string[];
+  })[];
+}
+//#endregion
+export { EventConfiguration };
+//# sourceMappingURL=event-configuration.d.ts.map

package/dist/RS/types/events.d.ts

@@ -0,0 +1,27 @@
+import { Types } from "./index.js";
+
+//#region src/RS/types/events.d.ts
+interface Event {
+  id: string;
+  length: number;
+  name?: string;
+  potentialCenter?: number;
+  density?: number;
+  weight?: number;
+  minBreakLength?: Types.breakLength;
+  maxLengthVariance?: number;
+  start?: number;
+  lockedTimes?: Types.lockedTime[];
+  intervals?: string | Types.interval[][];
+  days?: (Types.day | number)[];
+  day?: number;
+  groups?: Types.groupReference[][];
+  dependencies?: (Types.availableDependency[] | Types.availableDependency | string | string[])[];
+  period?: number;
+  forcedOverlapId?: string;
+  distributionKey?: string | string[];
+  meta?: Record<string, unknown>;
+}
+//#endregion
+export { Event };
+//# sourceMappingURL=events.d.ts.map