@royalschedule/maps 4.1.4 → 4.1.5

package/dist/RS/to/input/input.mjs

@@ -0,0 +1,59 @@
+import { fromLocations } from "./dependencies.mjs";
+import { extractUniqueIntervals } from "./intervals.mjs";
+import { fromTeachers } from "./teachers.mjs";
+import { fromEvents } from "./events.mjs";
+import { parseSettings } from "./settings.mjs";
+import { parseDefault } from "./default.mjs";
+import { fromLockedTimes } from "./locked-times.mjs";
+import { parsePeriods } from "./periods.mjs";
+import { fromGroups } from "./groups.mjs";
+import { extractUniqueIndividuals } from "./individuals.mjs";
+import { fromLinkedEventsSets } from "./linked-events-sets.mjs";
+
+//#region src/RS/to/input/input.ts
+function parseInput(data, options = {}) {
+	const _settings = data.settings;
+	const _division = data.division;
+	const _groups = data.groups ?? [];
+	const _teachers = data.teachers ?? [];
+	const _locations = data.locations ?? [];
+	const _events = data.events ?? [];
+	const _lockedTimes = data.lockedTimes ?? [];
+	const _courses = data.courses ?? [];
+	const _persons = data.persons ?? [];
+	const _periods = data.periods ?? [];
+	const _linkedEventsSets = data.linkedEventsSets ?? [];
+	[
+		_groups,
+		_teachers,
+		_courses,
+		_events,
+		_lockedTimes
+	].forEach((entities) => {
+		entities.forEach((entity) => {
+			if (entity.intervals && entity.intervals.length == 0) entity.intervals = void 0;
+			else if (entity.intervals === null) entity.intervals = void 0;
+		});
+	});
+	const _fromEvents = fromEvents(_events, _settings, options);
+	const _fromLockedTimes = fromLockedTimes(_lockedTimes, _settings, options);
+	const linkedEvents = fromLinkedEventsSets(_linkedEventsSets, _settings, new Set(_fromEvents.events.map((x) => x.id)), options);
+	return {
+		settings: parseSettings(_settings),
+		default: parseDefault(_settings, options),
+		periods: parsePeriods(_periods, _division, options),
+		intervals: extractUniqueIntervals(_settings, _groups, _teachers, _courses, _events, _lockedTimes, options),
+		dependencies: fromLocations(_locations, _settings, options),
+		groups: [...fromGroups(_groups, _settings, options), ...fromTeachers(_teachers, _settings, options)],
+		individuals: extractUniqueIndividuals(_persons, _courses, _events, _lockedTimes, options),
+		blockedTimes: _fromLockedTimes.blockedTimes,
+		events: [..._fromEvents.events, ..._fromLockedTimes.events],
+		activities: [..._fromEvents.activities, ..._fromLockedTimes.activities],
+		linkedEvents,
+		unitableEvents: []
+	};
+}
+
+//#endregion
+export { parseInput };
+//# sourceMappingURL=input.mjs.map

package/dist/RS/to/input/input.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.mjs","names":[],"sources":["../../../../src/RS/to/input/input.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport type { ConnectedScheduleData } from '../../make-connected';\nimport { fromLocations } from './dependencies';\nimport { fromTeachers } from './teachers';\nimport { fromEvents } from './events';\nimport { parseSettings } from './settings';\nimport { parseDefault } from './default';\nimport { fromLockedTimes } from './locked-times';\nimport { parsePeriods } from './periods';\nimport { fromGroups } from './groups';\nimport { extractUniqueIntervals } from './intervals';\nimport { extractUniqueIndividuals } from './individuals';\nimport { fromLinkedEventsSets } from './linked-events-sets';\n\nexport function parseInput (\n  data:    ConnectedScheduleData,\n  options: Types.parsedToOptions = {}\n): Types.scheduleData {\n\n  const _settings         = data.settings;\n  const _division         = data.division;\n  const _groups           = data.groups           ?? [];\n  const _teachers         = data.teachers         ?? [];\n  const _locations        = data.locations        ?? [];\n  const _events           = data.events           ?? [];\n  const _lockedTimes      = data.lockedTimes      ?? [];\n  const _courses          = data.courses          ?? [];\n  const _persons          = data.persons          ?? [];\n  const _periods          = data.periods          ?? [];\n  const _linkedEventsSets = data.linkedEventsSets ?? [];\n\n\n  ////\n  //// replace empty/null intervals with undefined\n  ////\n  [_groups, _teachers, /* _locations, */ _courses, _events, _lockedTimes].forEach(entities => {\n    entities.forEach(entity => {\n      if      (entity.intervals && entity.intervals.length == 0) entity.intervals = undefined;\n      else if (entity.intervals === null                       ) entity.intervals = undefined;\n    });\n  });\n\n  const _fromEvents      = fromEvents     (_events,      _settings, options);\n  const _fromLockedTimes = fromLockedTimes(_lockedTimes, _settings, options);\n\n  const presentEventIds = new Set(_fromEvents.events.map(x => x.id));\n\n  const linkedEvents = fromLinkedEventsSets(_linkedEventsSets, _settings, presentEventIds, options);\n\n  const out: Types.scheduleData = {\n    settings: parseSettings(_settings),\n    default:  parseDefault (_settings, options),\n\n    periods:   parsePeriods(_periods, _division, options),\n    intervals: extractUniqueIntervals(_settings, _groups, _teachers, _courses, _events, _lockedTimes, options),\n\n    dependencies: fromLocations(_locations, _settings, options),\n\n    groups: [\n      ...fromGroups  (_groups, _settings, options),\n      ...fromTeachers(_teachers, _settings, options)\n    ],\n\n    individuals: extractUniqueIndividuals(_persons, _courses, _events, _lockedTimes, options),\n\n    blockedTimes: _fromLockedTimes.blockedTimes,\n\n    events: [\n      ..._fromEvents.events,\n      ..._fromLockedTimes.events\n    ],\n\n    activities: [\n      ..._fromEvents.activities,\n      ..._fromLockedTimes.activities\n    ],\n\n    linkedEvents: linkedEvents,\n\n    unitableEvents: [],\n  };\n  return out;\n};"],"mappings":";;;;;;;;;;;;;AAcA,SAAgB,WACd,MACA,UAAiC,EAAE,EACf;CAEpB,MAAM,YAAoB,KAAK;CAC/B,MAAM,YAAoB,KAAK;CAC/B,MAAM,UAAoB,KAAK,UAAoB,EAAE;CACrD,MAAM,YAAoB,KAAK,YAAoB,EAAE;CACrD,MAAM,aAAoB,KAAK,aAAoB,EAAE;CACrD,MAAM,UAAoB,KAAK,UAAoB,EAAE;CACrD,MAAM,eAAoB,KAAK,eAAoB,EAAE;CACrD,MAAM,WAAoB,KAAK,WAAoB,EAAE;CACrD,MAAM,WAAoB,KAAK,WAAoB,EAAE;CACrD,MAAM,WAAoB,KAAK,WAAoB,EAAE;CACrD,MAAM,oBAAoB,KAAK,oBAAoB,EAAE;AAMrD;EAAC;EAAS;EAA6B;EAAU;EAAS;EAAa,CAAC,SAAQ,aAAY;AAC1F,WAAS,SAAQ,WAAU;AACzB,OAAS,OAAO,aAAa,OAAO,UAAU,UAAU,EAAG,QAAO,YAAY;YACrE,OAAO,cAAc,KAA6B,QAAO,YAAY;IAC9E;GACF;CAEF,MAAM,cAAmB,WAAgB,SAAc,WAAW,QAAQ;CAC1E,MAAM,mBAAmB,gBAAgB,cAAc,WAAW,QAAQ;CAI1E,MAAM,eAAe,qBAAqB,mBAAmB,WAFrC,IAAI,IAAI,YAAY,OAAO,KAAI,MAAK,EAAE,GAAG,CAAC,EAEuB,QAAQ;AAkCjG,QAhCgC;EAC9B,UAAU,cAAc,UAAU;EAClC,SAAU,aAAc,WAAW,QAAQ;EAE3C,SAAW,aAAa,UAAU,WAAW,QAAQ;EACrD,WAAW,uBAAuB,WAAW,SAAS,WAAW,UAAU,SAAS,cAAc,QAAQ;EAE1G,cAAc,cAAc,YAAY,WAAW,QAAQ;EAE3D,QAAQ,CACN,GAAG,WAAa,SAAS,WAAW,QAAQ,EAC5C,GAAG,aAAa,WAAW,WAAW,QAAQ,CAC/C;EAED,aAAa,yBAAyB,UAAU,UAAU,SAAS,cAAc,QAAQ;EAEzF,cAAc,iBAAiB;EAE/B,QAAQ,CACN,GAAG,YAAY,QACf,GAAG,iBAAiB,OACrB;EAED,YAAY,CACV,GAAG,YAAY,YACf,GAAG,iBAAiB,WACrB;EAEa;EAEd,gBAAgB,EAAE;EACnB"}

package/dist/RS/to/input/intervals.mjs

@@ -0,0 +1,129 @@
+import { getDayIndex } from "../../../core/util.mjs";
+import { makeChainable } from "../../../common/make-chainable/index.mjs";
+import { idOf } from "./util/util.mjs";
+import { groupBy, uniqBy } from "lodash-es";
+import moment from "moment";
+
+//#region src/RS/to/input/intervals.ts
+/**
+* Parses a date input into a moment object.
+*
+* Accepts an ISO date string, a string in 'HH:mm' format, or a DateType.
+* - If the input is in 'HH:mm' format, it is parsed as a UTC time on the epoch date.
+* - Otherwise, the input is parsed as a full UTC date.
+*
+* @param date - The date input to parse.
+* @returns A moment object representing the parsed date and time.
+*/
+function parseIntervalDate(date) {
+	if (typeof date == "string") {
+		if (/^\d{1,2}:\d{2}$/.test(date)) return moment.utc(date, "HH:mm");
+		return moment.utc(date);
+	}
+	return moment.utc(date);
+}
+/**
+* Removes the shorthand notation (a single day to represent all days)
+*/
+function standardizeIntervals(intervals, settings) {
+	if (intervals?.length == 1) {
+		const i = intervals[0];
+		const start = parseIntervalDate(i.start);
+		const end = parseIntervalDate(i.end);
+		return Array.from({ length: settings.numDays }, () => ({
+			start: start.clone(),
+			end: end.clone()
+		}));
+	}
+	return intervals;
+}
+/**
+* Converts the intervals to float type intervals
+*/
+function toFloatIntervals(intervals) {
+	return intervals?.map((i, day) => {
+		if (!i.start || !i.end) throw new Error(`(RS::To::toFloatIntervals) Interval missing start or end for day ${day}: ${JSON.stringify(i)}`);
+		return {
+			start: parseFloat(parseIntervalDate(i.start).format("HH.mm")),
+			end: parseFloat(parseIntervalDate(i.end).format("HH.mm"))
+		};
+	});
+}
+/**
+* Converts
+*/
+function combineAndMapIntervals(_intervals, rootInterval, settings) {
+	const intervals = toFloatIntervals(standardizeIntervals(_intervals, settings));
+	if (rootInterval) {
+		if (!intervals) throw new Error("(RS::To::combineAndMapIntervals) no accompanying intervals for rootInterval");
+		return makeChainable(rootInterval.intervals).chain((x) => groupBy(x, (i) => getDayIndex(i.start)), (x) => Object.entries(x).map(([day, is]) => {
+			const limits = intervals.at(parseInt(day));
+			if (!limits) throw new Error(`(RS::To::combineAndMapIntervals) Day ${day} not found in dayStartAndEnds`);
+			return is.map((i) => ({
+				start: parseFloat(parseIntervalDate(i.start).format("HH.mm")),
+				end: parseFloat(parseIntervalDate(i.end).format("HH.mm")),
+				binary: true
+			})).filter((i) => i.start >= limits.start && i.end <= limits.end);
+		}).reduce((acc, curr, index) => {
+			acc[index] = curr;
+			return acc;
+		}, Array.from({ length: settings.numDays }, () => []))).value;
+	}
+	if (intervals) return intervals.map((i) => [i]);
+}
+/**
+* extracts the default interval given the division settings
+*/
+function getDefaultInterval(settings) {
+	const { dayStart, dayEnd } = settings;
+	if (!dayStart) throw new Error("(RS::To::getDefaultInterval) \"settings.dayStart\" is falsy");
+	if (!dayEnd) throw new Error("(RS::To::getDefaultInterval) \"settings.dayEnd\" is falsy");
+	return [{
+		start: dayStart,
+		end: dayEnd
+	}];
+}
+/**
+* Computes the default interval id given the division settings
+*/
+function computesDefaultIntervalId(settings, options) {
+	return idOf.intervalPairReference(getDefaultInterval(settings), void 0, options);
+}
+/**
+* Extracts all unique intervals and interval-root interval pairs used by the provided entities
+*/
+function extractUniqueIntervals(settings, groups, teachers, courses, events, lockedTimes, options) {
+	const defaultInterval = getDefaultInterval(settings);
+	const withRootIntervals = [...groups, ...teachers].map((item) => {
+		const intervals = item.intervals ?? defaultInterval;
+		const rootInterval = item.rootInterval ?? settings.defaultRootInterval;
+		return {
+			id: idOf.intervalPairReference(intervals, rootInterval, options),
+			data: [intervals, rootInterval]
+		};
+	});
+	const withoutRootIntervals = [
+		{ intervals: defaultInterval },
+		...courses,
+		...events,
+		...lockedTimes
+	].map((item) => {
+		const interval = item.intervals ?? ("course" in item ? item.course?.intervals : void 0) ?? defaultInterval;
+		return {
+			id: idOf.intervalPairReference(interval, void 0, options),
+			data: [interval, void 0]
+		};
+	});
+	return makeChainable(withRootIntervals).chain((x) => x.concat(withoutRootIntervals), (x) => uniqBy(x, (x) => x.id), (x) => x.map(({ id, data: [_intervals, rootInterval] }) => {
+		const value = combineAndMapIntervals(_intervals, rootInterval, settings);
+		if (!value) return;
+		return {
+			id,
+			value
+		};
+	}).filter((x) => x != null)).value;
+}
+
+//#endregion
+export { computesDefaultIntervalId, extractUniqueIntervals, getDefaultInterval };
+//# sourceMappingURL=intervals.mjs.map

package/dist/RS/to/input/intervals.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervals.mjs","names":[],"sources":["../../../../src/RS/to/input/intervals.ts"],"sourcesContent":["import moment from 'moment';\nimport { groupBy, uniqBy } from 'lodash-es';\nimport type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { idOf } from './util/util';\nimport { getDayIndex } from '../../../core/util';\nimport type { DateType } from '../../../common/types';\nimport { makeChainable } from '../../../common/make-chainable';\nimport type { Interval } from '../../../core/interfaces';\n\n/**\n * Parses a date input into a moment object.\n *\n * Accepts an ISO date string, a string in 'HH:mm' format, or a DateType.\n * - If the input is in 'HH:mm' format, it is parsed as a UTC time on the epoch date.\n * - Otherwise, the input is parsed as a full UTC date.\n *\n * @param date - The date input to parse.\n * @returns A moment object representing the parsed date and time.\n */\nexport function parseIntervalDate (date: string | DateType): moment.Moment {\n  if (typeof date == 'string') {\n    // in case of HH:mm format, parse as UTC time on epoch date\n    if (/^\\d{1,2}:\\d{2}$/.test(date)) {\n      return moment.utc(date, 'HH:mm');\n    }\n\n    // otherwise parse as full date\n    return moment.utc(date);\n  }\n\n  return moment.utc(date);\n}\n\n/**\n * Removes the shorthand notation (a single day to represent all days)\n */\nfunction standardizeIntervals (\n  intervals:     Interval[] | undefined,\n  settings:      ConnectedTypes.divisionSettings\n): Interval[] | undefined {\n  if (intervals?.length == 1) {\n    const i = intervals[0];\n    const start = parseIntervalDate(i.start);\n    const end   = parseIntervalDate(i.end  );\n    return Array.from({ length: settings.numDays }, () => ({ start: start.clone(), end: end.clone() }));\n  }\n\n  return intervals;\n}\n\n/**\n * Converts the intervals to float type intervals\n */\nfunction toFloatIntervals (\n  intervals: Interval[] | undefined\n): { start: number, end: number }[] | undefined {\n  return intervals?.map((i, day: number) => {\n    if (!i.start || !i.end) throw new Error(`(RS::To::toFloatIntervals) Interval missing start or end for day ${day}: ${JSON.stringify(i)}`);\n    const start = parseFloat(parseIntervalDate(i.start).format('HH.mm'));\n    const end   = parseFloat(parseIntervalDate(i.end  ).format('HH.mm'));\n    return { start, end };\n  });\n}\n\n/**\n * Converts\n */\nfunction combineAndMapIntervals (\n  _intervals:    Interval[]           | undefined,\n  rootInterval:  ConnectedTypes.rootInterval | undefined,\n  settings:      ConnectedTypes.divisionSettings\n): Types.Shared.Interval[][] | undefined {\n  const intervals = toFloatIntervals(standardizeIntervals(_intervals, settings));\n\n  if (rootInterval) {\n    if (!intervals) throw new Error('(RS::To::combineAndMapIntervals) no accompanying intervals for rootInterval');\n    return makeChainable(rootInterval.intervals)\n      .chain(\n        x => groupBy(x, i => getDayIndex(i.start)),\n        x => Object.entries(x)\n          .map(([day, is]) => {\n            const limits = intervals.at(parseInt(day));\n            if (!limits) throw new Error(`(RS::To::combineAndMapIntervals) Day ${day} not found in dayStartAndEnds`);\n\n            // remove all block intervals that lay outside the day start and end\n            return is\n              .map(i => ({\n                start:  parseFloat(parseIntervalDate(i.start).format('HH.mm')),\n                end:    parseFloat(parseIntervalDate(i.end  ).format('HH.mm')),\n                binary: true\n              } satisfies Types.Shared.Interval))\n              .filter(i => i.start >= limits.start && i.end <= limits.end);\n          })\n          // ensure that all days are represented, even if empty\n          .reduce<Types.Shared.Interval[][]>((acc, curr, index) => {\n            acc[index] = curr;\n            return acc;\n          }, Array.from({ length: settings.numDays }, () => []))\n      )\n      .value;\n  }\n  if (intervals) {\n    return intervals.map(i => [i]);\n  }\n  return;\n};\n\n/**\n * extracts the default interval given the division settings\n */\nexport function getDefaultInterval (settings: ConnectedTypes.divisionSettings): Interval[] {\n  const { dayStart, dayEnd } = settings;\n  if (!dayStart) throw new Error('(RS::To::getDefaultInterval) \"settings.dayStart\" is falsy');\n  if (!dayEnd  ) throw new Error('(RS::To::getDefaultInterval) \"settings.dayEnd\" is falsy');\n  return [{ start: dayStart, end: dayEnd }];\n}\n\n/**\n * Computes the default interval id given the division settings\n */\nexport function computesDefaultIntervalId (\n  settings: ConnectedTypes.divisionSettings,\n  options:  Types.parsedToOptions\n): string {\n  return idOf.intervalPairReference(getDefaultInterval(settings), undefined, options);\n}\n\n/**\n * Extracts all unique intervals and interval-root interval pairs used by the provided entities\n */\nexport function extractUniqueIntervals (\n  settings:    ConnectedTypes.divisionSettings,\n  groups:      ConnectedTypes.group[],\n  teachers:    ConnectedTypes.teacher[],\n  courses:     ConnectedTypes.course[],\n  events:      ConnectedTypes.event[],\n  lockedTimes: ConnectedTypes.lockedTime[],\n  options:  Types.parsedToOptions\n): Types.Entities.Interval[] {\n  const defaultInterval = getDefaultInterval(settings);\n\n  type InheritedWithId = { id: string, data: [Interval<DateType>[] | undefined, ConnectedTypes.rootInterval | undefined] };\n\n  const withRootIntervals = [...groups, ...teachers]\n    .map((item): InheritedWithId => {\n      const intervals    = item.intervals    ?? defaultInterval;\n      const rootInterval = item.rootInterval ?? settings.defaultRootInterval;\n\n      return {\n        id:   idOf.intervalPairReference(intervals, rootInterval, options),\n        data: [intervals, rootInterval]\n      };\n    });\n\n  const withoutRootIntervals = [{ intervals: defaultInterval }, ...courses, ...events, ...lockedTimes]\n    .map((item): InheritedWithId => {\n      const interval = item.intervals ?? ('course' in item ? item.course?.intervals : undefined) ?? defaultInterval;\n\n      return {\n        id:   idOf.intervalPairReference(interval, undefined, options),\n        data: [interval, undefined]\n      };\n    });\n\n  return makeChainable(withRootIntervals)\n    .chain(\n      x => x.concat(withoutRootIntervals),\n      x => uniqBy(x, x => x.id),\n      x => x\n        .map(({ id, data: [_intervals, rootInterval] }) => {\n          // compute the corresponding root interval for each interval pair\n          const value = combineAndMapIntervals(_intervals, rootInterval, settings);\n          if (!value) return;\n          return { id, value } as Required<Types.Entities.Interval>;\n        })\n        .filter(x => x != null)\n    )\n    .value;\n};\n"],"mappings":"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"}

package/dist/RS/to/input/linked-events-sets.mjs

@@ -0,0 +1,96 @@
+import { getVertexId } from "../../../core/util.mjs";
+import { idOf } from "./util/util.mjs";
+
+//#region src/RS/to/input/linked-events-sets.ts
+function fromLinkedEventsSets(_linkedEventsSets, _settings, presentEventIds, options) {
+	return (_linkedEventsSets ?? []).map((x) => {
+		if (x.type === "parallel") {
+			if (x.anchor == null) throw new Error(`Linked events set ${getVertexId(x, options)} of type "parallel" is missing "anchor" property`);
+			return {
+				...x,
+				type: "parallel",
+				anchor: x.anchor
+			};
+		} else if (x.type === "sequential") {
+			if (x.gap == null) throw new Error(`Linked events set ${getVertexId(x, options)} of type "sequential" is missing "gap" property`);
+			return {
+				...x,
+				type: "sequential",
+				gap: x.gap
+			};
+		} else if (x.type === "custom") return {
+			...x,
+			type: "custom"
+		};
+		throw new Error(`Linked events set ${getVertexId(x, options)} is missing "type" property`);
+	}).map((x) => {
+		const id = getVertexId(x, options);
+		const restrictedEvents = x.events.filter((x) => presentEventIds.has(idOf.event(x, options)));
+		const type = x.type;
+		if (type === "parallel") {
+			const configurations = [];
+			const anchor = x.anchor;
+			switch (anchor) {
+				case "start":
+					configurations.push(restrictedEvents.map(() => ({
+						anchor: "start",
+						offset: 0
+					})));
+					break;
+				case "end":
+					configurations.push(restrictedEvents.map(() => ({
+						anchor: "end",
+						offset: 0
+					})));
+					break;
+				case "middle":
+					configurations.push(restrictedEvents.map(() => ({
+						anchor: "middle",
+						offset: 0
+					})));
+					break;
+				default: throw new Error(`Unrecognized anchor "${anchor}" in linked events set ${getVertexId(x, options)}`);
+			}
+			return {
+				id,
+				configurations,
+				events: restrictedEvents.map((x) => idOf.event(x, options))
+			};
+		}
+		if (type === "sequential") {
+			const { min, max } = x.gap;
+			const dt = _settings.discretization;
+			const numConfigurations = Math.pow(1 + Math.round(max / dt - min / dt), restrictedEvents.length - 1);
+			const maxNumConfigurations = 49;
+			if (numConfigurations >= maxNumConfigurations) throw new Error(`Linked events set ${getVertexId(x, options)} has too many configurations (${numConfigurations}, max allowed is ${maxNumConfigurations})`);
+			const gaps = [];
+			for (let i = min; i <= max; i += dt) gaps.push(i);
+			let configurations = [[{
+				anchor: "start",
+				offset: 0
+			}]];
+			for (let i = 1; i < restrictedEvents.length; i++) {
+				const newConfigurations = [];
+				for (const config of configurations) {
+					const lastOffsetBottom = config[config.length - 1].offset + restrictedEvents[i - 1].preferredDuration;
+					for (const gap of gaps) newConfigurations.push([...config, {
+						anchor: "start",
+						offset: lastOffsetBottom + gap
+					}]);
+				}
+				configurations = newConfigurations;
+			}
+			return {
+				id,
+				configurations,
+				events: restrictedEvents.map((x) => idOf.event(x, options))
+			};
+		}
+		if (type === "custom") throw new Error(`Custom linked events sets are not yet supported (linked events set ${getVertexId(x, options)})`);
+		throw new Error(`Unrecognized linked events set type "${type}" in linked events set ${getVertexId(x, options)}`);
+	}).filter((x) => x.events.length > 1);
+}
+
+//#endregion
+export { fromLinkedEventsSets };
+//# sourceMappingURL=linked-events-sets.mjs.map

package/dist/RS/to/input/linked-events-sets.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked-events-sets.mjs","names":[],"sources":["../../../../src/RS/to/input/linked-events-sets.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getVertexId } from '../../../core/util';\nimport { idOf } from './util/util';\n\n\nexport function fromLinkedEventsSets (\n  _linkedEventsSets: ConnectedTypes.linkedEventsSet[],\n  _settings:         ConnectedTypes.divisionSettings,\n  presentEventIds:   Set<string>,\n  options:           Types.parsedToOptions\n): Types.Entities.LinkedEventsSet[] {\n\n  return (_linkedEventsSets ?? [])\n    .map(x => {\n      // ensure that linkedEventsSets conform to the expected union that is currently not enforced by the schema\n      if (x.type === 'parallel') {\n        if (x.anchor == null) throw new Error(`Linked events set ${getVertexId(x, options)} of type \"parallel\" is missing \"anchor\" property`);\n        return { ...x, type: 'parallel', anchor: x.anchor } as const;\n      }\n      else if (x.type === 'sequential') {\n        if (x.gap == null) throw new Error(`Linked events set ${getVertexId(x, options)} of type \"sequential\" is missing \"gap\" property`);\n        return { ...x, type: 'sequential', gap: x.gap } as const;\n      }\n      else if (x.type === 'custom') {\n        return { ...x, type: 'custom' } as const;\n      }\n\n      throw new Error(`Linked events set ${getVertexId(x, options)} is missing \"type\" property`);\n    })\n    .map((x): Types.Entities.LinkedEventsSet => {\n      type Configurations = Types.Entities.LinkedEventsSet['configurations'];\n      const id = getVertexId(x, options);\n\n      const restrictedEvents = x.events.filter(x => presentEventIds.has(idOf.event(x, options)));\n      const type = x.type;\n      if (type === 'parallel') {\n        const configurations: Configurations = [];\n        const anchor = x.anchor;\n        switch (anchor) {\n          case 'start':  configurations.push(restrictedEvents.map(() => ({ anchor: 'start',  offset: 0 }))); break;\n          case 'end':    configurations.push(restrictedEvents.map(() => ({ anchor: 'end',    offset: 0 }))); break;\n          case 'middle': configurations.push(restrictedEvents.map(() => ({ anchor: 'middle', offset: 0 }))); break;\n          default: throw new Error(`Unrecognized anchor \"${anchor satisfies never as string}\" in linked events set ${getVertexId(x, options)}`);\n        }\n        return {\n          id, configurations,\n          events: restrictedEvents.map(x => idOf.event(x, options))\n        };\n      }\n\n      if (type === 'sequential') {\n        const { min, max } = x.gap;\n        const dt = _settings.discretization;\n\n        const numConfigurations = Math.pow(1 + Math.round(max/dt - min/dt), restrictedEvents.length - 1);\n        const maxNumConfigurations = 49; // max 3 events and a maximum gap range of 30 minutes => 7^2 = 49\n        if (numConfigurations >= maxNumConfigurations) throw new Error(`Linked events set ${getVertexId(x, options)} has too many configurations (${numConfigurations}, max allowed is ${maxNumConfigurations})`);\n\n        const gaps: number[] = [];\n        for (let i = min; i <= max; i += dt) gaps.push(i);\n\n        let configurations: Configurations = [[{ anchor: 'start', offset: 0 }]]; // first event is always at offset 0\n        for (let i = 1; i < restrictedEvents.length; i++) {\n          const newConfigurations: Configurations = [];\n          for (const config of configurations) {\n            const lastOffsetBottom = config[config.length - 1].offset + restrictedEvents[i - 1].preferredDuration;\n            for (const gap of gaps) {\n              newConfigurations.push([...config, { anchor: 'start', offset: lastOffsetBottom + gap }]);\n            }\n          }\n          configurations = newConfigurations;\n        }\n\n        return {\n          id, configurations,\n          events: restrictedEvents.map(x => idOf.event(x, options))\n        };\n      }\n\n      if (type === 'custom') {\n        throw new Error(`Custom linked events sets are not yet supported (linked events set ${getVertexId(x, options)})`);\n      }\n\n      throw new Error(`Unrecognized linked events set type \"${type satisfies never as string}\" in linked events set ${getVertexId(x, options)}`);\n    })\n    .filter(x => x.events.length > 1); // filter out linked events sets that only contain one event after filtering out events that are not present\n}"],"mappings":"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"}

package/dist/RS/to/input/locked-times.mjs

@@ -0,0 +1,89 @@
+import { getDayIndex, parseDateInterval } from "../../../core/util.mjs";
+import { makeChainable } from "../../../common/make-chainable/index.mjs";
+import { idOf } from "./util/util.mjs";
+import { getDefaultInterval } from "./intervals.mjs";
+import { parseGroupReferences } from "./util/parse-group-references.mjs";
+import { parseLocationReferences } from "./util/parse-location-references.mjs";
+import { toDayAndStart } from "./events.mjs";
+import { groupBy, omitBy, uniq } from "lodash-es";
+
+//#region src/RS/to/input/locked-times.ts
+function parseRegular(lockedTime, options) {
+	const { start: startDate, end: endDate } = parseDateInterval(lockedTime, "locked time");
+	const duration = endDate.diff(startDate, "minutes");
+	if (duration < 5) throw new Error("(RS::To::parseRegular) Length of a locked time is less than 5 min");
+	const start = parseFloat(startDate.format("HH.mm"));
+	const day = getDayIndex(startDate);
+	const doc = {
+		id: idOf.lockedTime(lockedTime, options),
+		day,
+		start,
+		duration
+	};
+	if (options.includeEntityMeta) doc.name = lockedTime.displayName;
+	return doc;
+}
+function parseDynamic(lockedTime, settings, options, defaultInterval) {
+	const duration = lockedTime.duration;
+	if (!duration || duration < 5) throw new Error("(RS::To::parseDynamic) Length of a locked time is less than 5 min");
+	const dependencyReferences = parseLocationReferences(lockedTime.coalesced, options);
+	const days = lockedTime.intervals ? makeChainable(lockedTime.intervals).chain((x) => x.map((x) => getDayIndex(x.start)), (x) => uniq(x)).value : void 0;
+	const day = days?.length == 1 ? days[0] : void 0;
+	if (day != null && lockedTime.coalesced) {
+		if (!lockedTime.coalesced.every((x) => !x.to.days?.length || x.to.days.some((x) => x.day == day))) return;
+	}
+	const distributionKey = lockedTime.type == "COMPLEMENTARY_TIME" ? "COMPLEMENTARY_TIME." + lockedTime.tags?.at(0)?.value : void 0;
+	const intervals = lockedTime.intervals ?? defaultInterval;
+	const doc = {
+		id: idOf.lockedTime(lockedTime, options),
+		duration,
+		minBreakDuration: false,
+		maxDurationVariance: lockedTime.durationVariance,
+		groups: parseGroupReferences({
+			type: "lockedTime",
+			item: lockedTime
+		}, options),
+		dependencies: dependencyReferences,
+		intervals: idOf.intervalPairReference(intervals, void 0, options),
+		distributionKey,
+		...days && { days },
+		...day && { day }
+	};
+	if (options.partialScheduleOptions) {
+		const { includedEvents, omittedEventsHandling } = options.partialScheduleOptions;
+		if (includedEvents && !includedEvents.has(doc.id)) {
+			if (omittedEventsHandling == "ignore") return;
+			if (omittedEventsHandling == "freeze") {
+				if (lockedTime.parked || !lockedTime.start || !lockedTime.duration) return;
+				Object.assign(doc, toDayAndStart(lockedTime.start));
+				doc.duration = lockedTime.duration;
+				doc.maxDurationVariance = 0;
+				const numDays = settings.numDays ?? 5;
+				doc.days = Array.from({ length: numDays }, (_, i) => i);
+				doc.intervals = Array.from({ length: numDays }, () => [{
+					start: 0,
+					end: 24
+				}]);
+			}
+		}
+	}
+	return omitBy(doc, (x) => x == null);
+}
+function fromLockedTimes(lockedTimes, settings, options) {
+	const defaultInterval = getDefaultInterval(settings);
+	const blockedTimes = lockedTimes.filter((x) => x.type == null || x.type == "ANY").map((lockedTime) => parseRegular(lockedTime, options)).filter((x) => !!x);
+	const complementaryHours = lockedTimes.filter((x) => x.type == "COMPLEMENTARY_TIME").map((x) => parseDynamic(x, settings, options, defaultInterval)).filter((x) => !!x);
+	const lunches = lockedTimes.filter((x) => x.type == "LUNCH").map((lockedTime) => parseDynamic(lockedTime, settings, options, defaultInterval)).filter((x) => !!x);
+	return {
+		events: [...complementaryHours, ...lunches],
+		activities: Object.entries(groupBy(complementaryHours, (x) => [x.distributionKey].flat().toSorted().join("|"))).map(([id, events]) => ({
+			id: `COMPLEMENTARY_TIME.${id}`,
+			events: events.map((x) => x.id)
+		})),
+		blockedTimes
+	};
+}
+
+//#endregion
+export { fromLockedTimes };
+//# sourceMappingURL=locked-times.mjs.map

package/dist/RS/to/input/locked-times.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"locked-times.mjs","names":[],"sources":["../../../../src/RS/to/input/locked-times.ts"],"sourcesContent":["import { groupBy, omitBy, uniq } from 'lodash-es';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getDayIndex, parseDateInterval } from '../../../core/util';\nimport { idOf } from './util/util';\nimport { parseGroupReferences } from './util/parse-group-references';\nimport type { Types } from '../../types';\nimport { makeChainable } from '../../../common/make-chainable';\nimport { toDayAndStart } from './events';\nimport { getDefaultInterval } from './intervals';\nimport type { Interval } from '../../../core/interfaces';\nimport { parseLocationReferences } from './util/parse-location-references';\n\nfunction parseRegular (\n  lockedTime: ConnectedTypes.lockedTime,\n  options:    Types.parsedToOptions,\n): Types.Entities.BlockedTime | undefined {\n  const { start: startDate, end: endDate } = parseDateInterval(lockedTime, 'locked time');\n\n  const duration = endDate.diff(startDate, 'minutes');\n  if (duration < 5) throw new Error('(RS::To::parseRegular) Length of a locked time is less than 5 min');\n\n  const start = parseFloat(startDate.format('HH.mm'));\n  const day   = getDayIndex(startDate);\n\n  const doc: Types.Entities.BlockedTime = {\n    id:       idOf.lockedTime(lockedTime, options),\n    day:      day,\n    start:    start,\n    duration: duration,\n  };\n\n  if (options.includeEntityMeta) {\n    doc.name = lockedTime.displayName;\n  }\n\n  return doc;\n};\n\nfunction parseDynamic (\n  lockedTime:      ConnectedTypes.lockedTime,\n  settings:        ConnectedTypes.divisionSettings,\n  options:         Types.parsedToOptions,\n  defaultInterval: Interval[]\n) {\n  const duration = lockedTime.duration;\n  if (!duration || duration < 5) throw new Error('(RS::To::parseDynamic) Length of a locked time is less than 5 min');\n\n  // Parse location dependencies directly from coalesced edges.\n  const dependencyReferences = parseLocationReferences(lockedTime.coalesced, options);\n\n  const days = lockedTime.intervals\n    ? makeChainable(lockedTime.intervals)\n      .chain(\n        x => x.map(x => getDayIndex(x.start)),\n        x => uniq(x),\n      )\n      .value\n    : undefined;\n  const day = days?.length == 1 ? days[0] : undefined;\n\n  // ignore locked times that reside on days that are not part of any coalesced's days\n  if (day != null && lockedTime.coalesced) {\n    const allowedByEvery = lockedTime.coalesced.every(x => !x.to.days?.length || x.to.days.some(x => x.day == day));\n    if (!allowedByEvery) return;\n  }\n\n  // each type (tag) of complementary hours should distribute evenly\n  const distributionKey = lockedTime.type == 'COMPLEMENTARY_TIME'\n    ? 'COMPLEMENTARY_TIME.' + lockedTime.tags?.at(0)?.value\n    : undefined;\n\n  const intervals = lockedTime.intervals ?? defaultInterval;\n\n  const doc: Types.Entities.Event = {\n    id:                  idOf.lockedTime(lockedTime, options),\n    duration:            duration,\n    minBreakDuration:    false,\n    maxDurationVariance: lockedTime.durationVariance,\n    groups:              parseGroupReferences({ type: 'lockedTime', item: lockedTime }, options),\n    dependencies:        dependencyReferences,\n    intervals:           idOf.intervalPairReference(intervals, undefined, options),\n    distributionKey,\n    ...days && { days },\n    ...day && { day },\n  };\n\n\n  ////\n  //// filter based on partialScheduleOptions\n  ////\n  if (options.partialScheduleOptions) {\n    const { includedEvents, omittedEventsHandling } = options.partialScheduleOptions;\n    if (includedEvents && !includedEvents.has(doc.id)) {\n\n      if (omittedEventsHandling == 'ignore') return;\n\n      if (omittedEventsHandling == 'freeze') {\n        // must not be parked and have a start and duration to be frozen, otherwise it's ignored\n        if (lockedTime.parked || !lockedTime.start || !lockedTime.duration) return;\n\n        // fix day, start and end\n        Object.assign(doc, toDayAndStart(lockedTime.start));\n        doc.duration = lockedTime.duration;\n        doc.maxDurationVariance = 0;\n\n        // override intervals and days to not cause conflicts\n        const numDays = settings.numDays ?? 5;\n        doc.days      = Array.from({ length: numDays }, (_, i) => i);\n        doc.intervals = Array.from({ length: numDays }, () => [{ start: 0, end: 24.00 }]);\n\n        // fix locations\n        // > locations are always fixed for locked times\n      }\n    }\n  }\n\n  return omitBy(doc, x => x == null) as Types.Entities.Event;\n}\n\ntype Out = {\n  events:       Types.Entities.Event[];\n  activities:   Types.Entities.Activity[];\n  blockedTimes: Types.Entities.BlockedTime[];\n};\nexport function fromLockedTimes (\n  lockedTimes: ConnectedTypes.lockedTime[],\n  settings:    ConnectedTypes.divisionSettings,\n  options:     Types.parsedToOptions,\n): Out {\n  const defaultInterval = getDefaultInterval(settings);\n\n  const blockedTimes = lockedTimes\n    .filter(x => x.type == null || x.type == 'ANY')\n    .map(lockedTime => parseRegular(lockedTime, options))\n    .filter(x => !!x) as Types.Entities.BlockedTime[];\n\n  const complementaryHours = lockedTimes\n    .filter(x => x.type == 'COMPLEMENTARY_TIME')\n    .map(x => parseDynamic(x, settings, options, defaultInterval))\n    .filter(x => !!x);\n\n  const lunches = lockedTimes\n    .filter(x => x.type == 'LUNCH')\n    .map(lockedTime => parseDynamic(lockedTime, settings, options, defaultInterval))\n    .filter(x => !!x);\n\n  const events = [...complementaryHours, ...lunches];\n\n  const activities = Object.entries(groupBy(complementaryHours, x => [x.distributionKey].flat().toSorted().join('|')))\n    .map(([id, events]) => ({ id: `COMPLEMENTARY_TIME.${id}`, events: events.map(x => x.id) }));\n\n  return { events, activities, blockedTimes };\n};"],"mappings":"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"}

package/dist/RS/to/input/periods.mjs

@@ -0,0 +1,57 @@
+import { range } from "../../../common/functions.mjs";
+import { getVertexId } from "../../../core/util.mjs";
+import moment from "moment";
+
+//#region src/RS/to/input/periods.ts
+function createRange({ start, end }) {
+	return {
+		start: moment.utc(start).clone().startOf("isoWeek"),
+		end: moment.utc(end).clone().endOf("isoWeek")
+	};
+}
+function parsePeriods(periods, division, options) {
+	const divisionRange = createRange(division);
+	const weeksMap = /* @__PURE__ */ new Map();
+	for (const x = divisionRange.start.clone(); x.isSameOrBefore(divisionRange.end); x.add(1, "week")) weeksMap.set(x.toISOString(), false);
+	const out = periods.map((p) => {
+		const id = getVertexId(p, options);
+		const clippedRanges = p.ranges.map((r) => createRange(r)).filter((r) => range.overlaps(r, divisionRange)).map((r) => ({
+			start: moment.max(r.start, divisionRange.start).clone(),
+			end: moment.min(r.end, divisionRange.end).clone()
+		}));
+		const activeWeeksMap = new Map(weeksMap);
+		clippedRanges.forEach((r) => {
+			for (const x = r.start.clone(); x.isSameOrBefore(r.end); x.add(1, "week")) {
+				const key = x.toISOString();
+				activeWeeksMap.set(key, true);
+			}
+		});
+		const weeks = Array.from(activeWeeksMap.entries()).sort((a, b) => moment.utc(a[0]).diff(moment.utc(b[0]))).map((x) => x[1] ? "1" : "0").join("");
+		return {
+			id,
+			weeks,
+			overlaps: weeks.length <= 64 ? weeks : ""
+		};
+	});
+	if (weeksMap.size > 64 && out && out.length <= 64) for (let i = 0; i < out.length; i++) {
+		let overlaps = "";
+		for (let j = 0; j < out.length; j++) {
+			if (i == j) {
+				overlaps += "1";
+				continue;
+			}
+			let overlap = false;
+			for (let k = 0; k < out[i].weeks.length; k++) if (out[i].weeks[k] === "1" && out[j].weeks[k] === "1") {
+				overlap = true;
+				break;
+			}
+			overlaps += overlap ? "1" : "0";
+		}
+		out[i].overlaps = overlaps;
+	}
+	return out;
+}
+
+//#endregion
+export { parsePeriods };
+//# sourceMappingURL=periods.mjs.map

package/dist/RS/to/input/periods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"periods.mjs","names":[],"sources":["../../../../src/RS/to/input/periods.ts"],"sourcesContent":["import moment from 'moment';\nimport { getVertexId } from '../../../core/util';\nimport type { ConnectedTypes } from '../../make-connected';\nimport type { Types } from '../../types';\nimport { range } from '../../../common/functions';\nimport type { Interval } from '../../../core/interfaces';\n\ntype Range = Partial<Interval<string | moment.Moment | Date>>;\ntype DateRange = Interval<moment.Moment>;\n\nfunction createRange ({ start, end }: Range): DateRange {\n  return {\n    start: moment.utc(start).clone().startOf('isoWeek'),\n    end:   moment.utc(end  ).clone().endOf  ('isoWeek')\n  };\n}\n\nexport function parsePeriods (\n  periods:  ConnectedTypes.period[],\n  division: ConnectedTypes.division,\n  options:  Types.parsedToOptions\n): Types.Entities.Period[] {\n  const divisionRange = createRange(division);\n\n  // build a mapping of week starts to boolean active flags\n  const weeksMap = new Map<string, boolean>();\n  for (const x = divisionRange.start.clone(); x.isSameOrBefore(divisionRange.end); x.add(1, 'week')) {\n    weeksMap.set(x.toISOString(), false);\n  }\n\n  const out = periods.map((p): Types.Entities.Period => {\n    const id = getVertexId(p, options);\n\n    // preserve only the ranges that lay within the division range\n    const clippedRanges = p.ranges\n      .map(r => createRange(r))\n      .filter(r => range.overlaps(r, divisionRange))\n      .map(r => ({\n        start: moment.max(r.start, divisionRange.start).clone(),\n        end:   moment.min(r.end,   divisionRange.end  ).clone()\n      }));\n\n    // get the active weeks by checking which weeks in the division are covered by the clipped ranges\n    const activeWeeksMap = new Map(weeksMap);\n    clippedRanges.forEach(r => {\n      for (const x = r.start.clone(); x.isSameOrBefore(r.end); x.add(1, 'week')) {\n        const key = x.toISOString();\n        activeWeeksMap.set(key, true);\n      }\n    });\n\n    // build the active weeks string\n    const weeks = Array.from(activeWeeksMap.entries())\n      .sort((a, b) => moment.utc(a[0]).diff(moment.utc(b[0])))\n      .map(x => x[1] ? '1' : '0')\n      .join('');\n\n    const overlaps = weeks.length <= 64 ? weeks : '';\n\n    return { id, weeks, overlaps };\n  });\n\n  // If there are more than 64 weeks but less than or equal to 64 periods, we compute the overlap between periods directly.\n  if (weeksMap.size > 64 && out && out.length <= 64) {\n    for (let i = 0; i < out.length; i++) {\n      let overlaps = '';\n      for (let j = 0; j < out.length; j++) {\n        // self-overlap\n        if (i == j) {\n          overlaps += '1';\n          continue;\n        }\n\n        // overlap with other periods\n        let overlap = false;\n        for (let k = 0; k < out[i].weeks.length; k++) {\n          if (out[i].weeks[k] === '1' && out[j].weeks[k] === '1') {\n            overlap = true;\n            break;\n          }\n        }\n        overlaps += overlap ? '1' : '0';\n      }\n      out[i].overlaps = overlaps;\n    }\n  }\n\n  return out;\n}"],"mappings":";;;;;AAUA,SAAS,YAAa,EAAE,OAAO,OAAyB;AACtD,QAAO;EACL,OAAO,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,UAAU;EACnD,KAAO,OAAO,IAAI,IAAM,CAAC,OAAO,CAAC,MAAQ,UAAU;EACpD;;AAGH,SAAgB,aACd,SACA,UACA,SACyB;CACzB,MAAM,gBAAgB,YAAY,SAAS;CAG3C,MAAM,2BAAW,IAAI,KAAsB;AAC3C,MAAK,MAAM,IAAI,cAAc,MAAM,OAAO,EAAE,EAAE,eAAe,cAAc,IAAI,EAAE,EAAE,IAAI,GAAG,OAAO,CAC/F,UAAS,IAAI,EAAE,aAAa,EAAE,MAAM;CAGtC,MAAM,MAAM,QAAQ,KAAK,MAA6B;EACpD,MAAM,KAAK,YAAY,GAAG,QAAQ;EAGlC,MAAM,gBAAgB,EAAE,OACrB,KAAI,MAAK,YAAY,EAAE,CAAC,CACxB,QAAO,MAAK,MAAM,SAAS,GAAG,cAAc,CAAC,CAC7C,KAAI,OAAM;GACT,OAAO,OAAO,IAAI,EAAE,OAAO,cAAc,MAAM,CAAC,OAAO;GACvD,KAAO,OAAO,IAAI,EAAE,KAAO,cAAc,IAAM,CAAC,OAAO;GACxD,EAAE;EAGL,MAAM,iBAAiB,IAAI,IAAI,SAAS;AACxC,gBAAc,SAAQ,MAAK;AACzB,QAAK,MAAM,IAAI,EAAE,MAAM,OAAO,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,EAAE,IAAI,GAAG,OAAO,EAAE;IACzE,MAAM,MAAM,EAAE,aAAa;AAC3B,mBAAe,IAAI,KAAK,KAAK;;IAE/B;EAGF,MAAM,QAAQ,MAAM,KAAK,eAAe,SAAS,CAAC,CAC/C,MAAM,GAAG,MAAM,OAAO,IAAI,EAAE,GAAG,CAAC,KAAK,OAAO,IAAI,EAAE,GAAG,CAAC,CAAC,CACvD,KAAI,MAAK,EAAE,KAAK,MAAM,IAAI,CAC1B,KAAK,GAAG;AAIX,SAAO;GAAE;GAAI;GAAO,UAFH,MAAM,UAAU,KAAK,QAAQ;GAEhB;GAC9B;AAGF,KAAI,SAAS,OAAO,MAAM,OAAO,IAAI,UAAU,GAC7C,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,IAAI,WAAW;AACf,OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AAEnC,OAAI,KAAK,GAAG;AACV,gBAAY;AACZ;;GAIF,IAAI,UAAU;AACd,QAAK,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,MAAM,QAAQ,IACvC,KAAI,IAAI,GAAG,MAAM,OAAO,OAAO,IAAI,GAAG,MAAM,OAAO,KAAK;AACtD,cAAU;AACV;;AAGJ,eAAY,UAAU,MAAM;;AAE9B,MAAI,GAAG,WAAW;;AAItB,QAAO"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"settings.mjs","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.Entities.Settings {\n\n  if (!settings.numDays)        throw new Error('(RS::To::parseSettings) numDays is falsy');\n  if (!settings.discretization) throw new Error('(RS::To::parseSettings) discretization is falsy');\n\n  return {\n    numDays:        settings.numDays,\n    discretization: settings.discretization,\n  };\n};"],"mappings":";AAGA,SAAgB,cAAe,UAAoE;AAEjG,KAAI,CAAC,SAAS,QAAgB,OAAM,IAAI,MAAM,2CAA2C;AACzF,KAAI,CAAC,SAAS,eAAgB,OAAM,IAAI,MAAM,kDAAkD;AAEhG,QAAO;EACL,SAAgB,SAAS;EACzB,gBAAgB,SAAS;EAC1B"}

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

@@ -0,0 +1,32 @@
+import { idOf } from "./util/util.mjs";
+import { parseDayIndices } from "./util/parse-days.mjs";
+import { parseMaxWorkingHours } from "./util/parse-max-working-hours.mjs";
+import { getDefaultInterval } from "./intervals.mjs";
+import { omitBy } from "lodash-es";
+
+//#region src/RS/to/input/teachers.ts
+function fromTeachers(teachers, settings, options) {
+	const defaultInterval = getDefaultInterval(settings);
+	return teachers.map((teacher) => {
+		const intervals = teacher.intervals ?? defaultInterval;
+		const rootInterval = teacher.rootInterval ?? settings.defaultRootInterval;
+		const doc = {
+			id: idOf.teacher(teacher, options),
+			group_type: "personal",
+			minimizeGaps: settings.minimizeTeacherGaps,
+			minimizeDependencyAlternation: true,
+			weight: teacher.weight,
+			intervals: idOf.intervalPairReference(intervals, rootInterval, options),
+			days: parseDayIndices(teacher.days, settings),
+			blockedTimes: teacher.lockedTimes?.map((x) => idOf.lockedTime(x, options)),
+			minBreakDuration: teacher.minBreakLength,
+			...parseMaxWorkingHours(teacher)
+		};
+		if (options.includeEntityMeta) doc.name = teacher.displayName;
+		return omitBy(doc, (x) => x == null);
+	});
+}
+
+//#endregion
+export { fromTeachers };
+//# sourceMappingURL=teachers.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"teachers.mjs","names":[],"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 { parseDayIndices } from './util/parse-days';\nimport { idOf } from './util/util';\nimport { getDefaultInterval } from './intervals';\n\nexport function fromTeachers (\n  teachers: ConnectedTypes.teacher[],\n  settings: ConnectedTypes.divisionSettings,\n  options:  Types.parsedToOptions\n): Types.Entities.Group[] {\n  const defaultInterval = getDefaultInterval(settings);\n\n  return teachers\n    .map(teacher => {\n      const intervals    = teacher.intervals    ?? defaultInterval;\n      const rootInterval = teacher.rootInterval ?? settings.defaultRootInterval;\n\n      const doc: Types.Entities.Group = {\n        id:                            idOf.teacher(teacher, options),\n        group_type:                    'personal',\n        minimizeGaps:                  settings.minimizeTeacherGaps,\n        minimizeDependencyAlternation: true,\n        weight:                        teacher.weight,\n        intervals:                     idOf.intervalPairReference(intervals, rootInterval, options),\n        days:                          parseDayIndices(teacher.days, settings),\n        blockedTimes:                  teacher.lockedTimes?.map(x => idOf.lockedTime(x, options)),\n        minBreakDuration:              teacher.minBreakLength,\n        ...parseMaxWorkingHours(teacher),\n      };\n\n      if (options.includeEntityMeta) {\n        doc.name = teacher.displayName;\n      }\n\n      return omitBy(doc, x => x == null) as Types.Entities.Group;\n    });\n};\n"],"mappings":";;;;;;;AAQA,SAAgB,aACd,UACA,UACA,SACwB;CACxB,MAAM,kBAAkB,mBAAmB,SAAS;AAEpD,QAAO,SACJ,KAAI,YAAW;EACd,MAAM,YAAe,QAAQ,aAAgB;EAC7C,MAAM,eAAe,QAAQ,gBAAgB,SAAS;EAEtD,MAAM,MAA4B;GAChC,IAA+B,KAAK,QAAQ,SAAS,QAAQ;GAC7D,YAA+B;GAC/B,cAA+B,SAAS;GACxC,+BAA+B;GAC/B,QAA+B,QAAQ;GACvC,WAA+B,KAAK,sBAAsB,WAAW,cAAc,QAAQ;GAC3F,MAA+B,gBAAgB,QAAQ,MAAM,SAAS;GACtE,cAA+B,QAAQ,aAAa,KAAI,MAAK,KAAK,WAAW,GAAG,QAAQ,CAAC;GACzF,kBAA+B,QAAQ;GACvC,GAAG,qBAAqB,QAAQ;GACjC;AAED,MAAI,QAAQ,kBACV,KAAI,OAAO,QAAQ;AAGrB,SAAO,OAAO,MAAK,MAAK,KAAK,KAAK;GAClC"}

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

@@ -0,0 +1,10 @@
+//#region src/RS/to/input/util/parse-days.ts
+function parseDayIndices(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 { parseDayIndices };
+//# sourceMappingURL=parse-days.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-days.mjs","names":[],"sources":["../../../../../src/RS/to/input/util/parse-days.ts"],"sourcesContent":["import type { ConnectedTypes } from '../../../make-connected';\nimport type { Types } from '../../../types';\n\nexport function parseDayIndices (\n  days:    ConnectedTypes.event['days'] | ConnectedTypes.course['days'],\n  settings: ConnectedTypes.divisionSettings\n): Types.Shared.DayIndices | undefined {\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":";AAGA,SAAgB,gBACd,MACA,UACqC;AACrC,KAAI,CAAC,KAAM;AAEX,KAAI,KAAK,OAAQ,QAAO,KAAK,KAAI,MAAK,EAAE,IAAI;AAG5C,QAAO,CAAC,GAAG,MAAM,KAAK,EAAE,QAAQ,SAAS,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG,MAAM,EAAE"}

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

@@ -0,0 +1,50 @@
+import { getVertexId } from "../../../../core/util.mjs";
+import { makeChainable } from "../../../../common/make-chainable/index.mjs";
+import { idOf } from "./util.mjs";
+import { groupBy } 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) => [x, ...(x.to.parentGroups ?? []).map((y) => ({
+		to: y,
+		isParentGroup: true
+	}))]), (x) => groupBy(x, (x) => getVertexId(x.to, options)), (x) => Object.values(x).map((xs) => xs.find((x) => x.isParentGroup) ?? xs.at(0)).filter((x) => x != 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);
+	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?.length ? { individuals: sources.participants.map((x) => idOf.person(x.to, options)) } : void 0;
+	return new Array().concat(teacherReferences, groupReferences, participantReferences ? [participantReferences] : []).map((x) => [x]);
+}
+
+//#endregion
+export { parseGroupReferences };
+//# sourceMappingURL=parse-group-references.mjs.map