@royalschedule/maps 3.3.17 → 4.0.1

package/dist/RS/{v3/to → to/input}/default.js

@@ -1,25 +1,17 @@
-import { min2hrs } from "./util.js";
+import { getPeriodIndex, min2hrs, toTimeFloat } from "./util/util.js";
+import { parseIntervals } from "./util/parse-intervals.js";
+import { computesDefaultIntervalId, getDefaultInterval } from "./intervals.js";
 
-//#region src/RS/v3/to/default.ts
-function toTime(str) {
-	return parseFloat(str.replace(":", "."));
-}
-var default_default = (settings, periodMap, options) => {
-	const { dayStart, dayEnd } = settings;
-	if (!dayStart) throw new Error("(RS::V3::To::Default) \"dayStart\" is falsy");
-	if (!dayEnd) throw new Error("(RS::V3::To::Default) \"dayEnd\" is falsy");
-	if (periodMap.size && !periodMap.has(settings.period?.id)) throw new Error("(RS::V3::To::Default) \"period\" is not in periodMap");
+//#region src/RS/to/input/default.ts
+function parseDefault(settings, periodsMap, options) {
 	const maxNumWorkingHours = options.useMaximumScheduleSpan ? min2hrs(settings.defaultMaximumScheduleSpan?.daily) ?? false : settings.defaultMaxNumWorkingHours ?? false;
 	const maxNumDailyWorkingHours = options.useMaximumScheduleSpan ? min2hrs(settings.defaultMaximumScheduleSpan?.daily) ?? false : settings.defaultMaxNumDailyWorkingHours ?? false;
 	const res = {
-		intervals: [[{
-			beg: toTime(dayStart),
-			end: toTime(dayEnd)
-		}]],
+		intervals: options.oldFormat ? parseIntervals(getDefaultInterval(settings), void 0, settings) : computesDefaultIntervalId(settings, options),
 		groupMinBreakLength: settings.defaultGroupMinimumBreakLength ?? 0,
 		dependencyMinBreakLength: settings.defaultDependencyMinimumBreakLength ?? 0,
 		eventMinBreakLength: settings.defaultEventMinimumBreakLength ?? 0,
-		potentialCenter: toTime(settings.potentialCenter ?? "12:00"),
+		potentialCenter: toTimeFloat(settings.potentialCenter ?? "12:00"),
 		eventDensity: settings.defaultEventDensity ?? 0,
 		maxEventLengthVariance: settings.defaultEventDurationVariance ?? 0,
 		maxNumWorkingHours,
@@ -30,11 +22,11 @@ var default_default = (settings, periodMap, options) => {
 		groupWeight: settings.defaultGroupWeight ?? 0,
 		collectionWeight: settings.defaultCourseWeight ?? 0,
 		eventWeight: settings.defaultEventWeight ?? 0,
-		...periodMap.size && { period: periodMap.get(settings.period?.id) }
+		period: getPeriodIndex(settings.period, periodsMap, options)
 	};
 	return res;
-};
+}
 
 //#endregion
-export { default_default as default };
+export { parseDefault };
 //# sourceMappingURL=default.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default.js","names":["res: Types.defaultValues"],"sources":["../../../../src/RS/to/input/default.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport { computesDefaultIntervalId, getDefaultInterval } from './intervals';\nimport { parseIntervals } from './util/parse-intervals';\nimport { getPeriodIndex, min2hrs, toTimeFloat } from './util/util';\nimport type { ConnectedTypes } from '../../make-connected';\n\nexport function parseDefault (\n  settings:   ConnectedTypes.divisionSettings,\n  periodsMap: Map<string | undefined, number>,\n  options:    Types.parsedToOptions\n): Types.defaultValues {\n  const maxNumWorkingHours = options.useMaximumScheduleSpan\n    ? min2hrs(settings.defaultMaximumScheduleSpan?.daily) ?? false\n    : settings.defaultMaxNumWorkingHours                  ?? false;\n\n  const maxNumDailyWorkingHours = options.useMaximumScheduleSpan\n    ? min2hrs(settings.defaultMaximumScheduleSpan?.daily) ?? false\n    : settings.defaultMaxNumDailyWorkingHours             ?? false;\n\n  const res: Types.defaultValues = {\n    intervals: options.oldFormat\n      ? parseIntervals(getDefaultInterval(settings), undefined, settings)!\n      : computesDefaultIntervalId(settings, options),\n\n    groupMinBreakLength:      settings.defaultGroupMinimumBreakLength      ?? 0,\n    dependencyMinBreakLength: settings.defaultDependencyMinimumBreakLength ?? 0,\n    eventMinBreakLength:      settings.defaultEventMinimumBreakLength      ?? 0,\n\n    potentialCenter: toTimeFloat(settings.potentialCenter ?? '12:00'),\n    eventDensity:    settings.defaultEventDensity ?? 0,\n\n    maxEventLengthVariance: settings.defaultEventDurationVariance ?? 0,\n\n    maxNumWorkingHours:      maxNumWorkingHours,\n    maxNumDailyWorkingHours: maxNumDailyWorkingHours,\n\n    dependencyRank: settings.defaultDependencyRank ?? 0,\n    groupRank:      settings.defaultGroupRank      ?? 0,\n    dayRank:        settings.defaultDayRank        ?? 0,\n\n    groupWeight:      settings.defaultGroupWeight  ?? 0,\n    collectionWeight: settings.defaultCourseWeight ?? 0,\n    eventWeight:      settings.defaultEventWeight  ?? 0,\n\n    period: getPeriodIndex(settings.period, periodsMap, options)\n  };\n\n  return res;\n};"],"mappings":";;;;;AAMA,SAAgB,aACd,UACA,YACA,SACqB;CACrB,MAAM,qBAAqB,QAAQ,yBAC/B,QAAQ,SAAS,4BAA4B,UAAU,QACvD,SAAS,6BAA8C;CAE3D,MAAM,0BAA0B,QAAQ,yBACpC,QAAQ,SAAS,4BAA4B,UAAU,QACvD,SAAS,kCAA8C;CAE3D,MAAMA,MAA2B;EAC/B,WAAW,QAAQ,YACf,eAAe,mBAAmB,WAAW,QAAW,YACxD,0BAA0B,UAAU;EAExC,qBAA0B,SAAS,kCAAuC;EAC1E,0BAA0B,SAAS,uCAAuC;EAC1E,qBAA0B,SAAS,kCAAuC;EAE1E,iBAAiB,YAAY,SAAS,mBAAmB;EACzD,cAAiB,SAAS,uBAAuB;EAEjD,wBAAwB,SAAS,gCAAgC;EAExC;EACA;EAEzB,gBAAgB,SAAS,yBAAyB;EAClD,WAAgB,SAAS,oBAAyB;EAClD,SAAgB,SAAS,kBAAyB;EAElD,aAAkB,SAAS,sBAAuB;EAClD,kBAAkB,SAAS,uBAAuB;EAClD,aAAkB,SAAS,sBAAuB;EAElD,QAAQ,eAAe,SAAS,QAAQ,YAAY;;AAGtD,QAAO"}

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

@@ -0,0 +1,32 @@
+import { getVertexId } from "../../../core/util.js";
+import { attachLockedTimes } from "./util/attach-locked-times.js";
+import { parseDays } from "./util/parse-days.js";
+import { omitBy } from "lodash-es";
+
+//#region src/RS/to/input/dependencies.ts
+function fromLocations(locations, settings, options) {
+	return locations.filter((x) => {
+		const id = getVertexId(x, options);
+		const includedLocations = options.partialScheduleOptions?.includedLocations;
+		if (includedLocations && !includedLocations.has(id)) return false;
+		return true;
+	}).map((location) => {
+		const id = getVertexId(location, options);
+		const doc = {
+			id,
+			area: location.area,
+			minBreakLength: location.minBreakLength,
+			days: parseDays(location.days, settings),
+			lockedTimes: attachLockedTimes(location.lockedTimes, options)
+		};
+		if (options.meta) doc.meta = omitBy({
+			ids: location.ids,
+			name: location.displayName
+		}, (x) => x == null);
+		return omitBy(doc, (x) => x == null);
+	});
+}
+
+//#endregion
+export { fromLocations };
+//# sourceMappingURL=dependencies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.js","names":["doc: Types.dependency"],"sources":["../../../../src/RS/to/input/dependencies.ts"],"sourcesContent":["import { omitBy } from 'lodash-es';\nimport { attachLockedTimes } from './util/attach-locked-times';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getVertexId } from '../../../core/util';\nimport { parseDays } from './util/parse-days';\nimport type { Types } from '../../types';\n\nexport function fromLocations (\n  locations: ConnectedTypes.location[],\n  settings:  ConnectedTypes.divisionSettings,\n  options:   Types.parsedToOptions\n) {\n  return locations\n    .filter(x => {\n      const id = getVertexId(x, options);\n\n      // filter location references based on partial schedule options\n      const includedLocations = options.partialScheduleOptions?.includedLocations;\n      if (includedLocations && !includedLocations.has(id)) return false;\n      return true;\n    })\n    .map(location => {\n      const id = getVertexId(location, options);\n\n      const doc: Types.dependency = {\n        id,\n        area:           location.area,\n        minBreakLength: location.minBreakLength,\n        days:           parseDays                (location.days, settings),\n        lockedTimes:    attachLockedTimes(location.lockedTimes, options)\n      };\n\n      if (options.meta) {\n        doc.meta = omitBy({\n          ids:  location.ids,\n          name: location.displayName\n        }, x => x == null);\n      }\n\n      return omitBy(doc, x => x == null) as Types.dependency;\n    });\n}"],"mappings":";;;;;;AAOA,SAAgB,cACd,WACA,UACA,SACA;AACA,QAAO,UACJ,QAAO,MAAK;EACX,MAAM,KAAK,YAAY,GAAG;EAG1B,MAAM,oBAAoB,QAAQ,wBAAwB;AAC1D,MAAI,qBAAqB,CAAC,kBAAkB,IAAI,IAAK,QAAO;AAC5D,SAAO;IAER,KAAI,aAAY;EACf,MAAM,KAAK,YAAY,UAAU;EAEjC,MAAMA,MAAwB;GAC5B;GACA,MAAgB,SAAS;GACzB,gBAAgB,SAAS;GACzB,MAAgB,UAA0B,SAAS,MAAM;GACzD,aAAgB,kBAAkB,SAAS,aAAa;;AAG1D,MAAI,QAAQ,KACV,KAAI,OAAO,OAAO;GAChB,KAAM,SAAS;GACf,MAAM,SAAS;MACd,MAAK,KAAK;AAGf,SAAO,OAAO,MAAK,MAAK,KAAK"}

package/dist/RS/to/input/dynamic-locked-times.js

@@ -0,0 +1,67 @@
+import { getDayIndex, getVertexId } from "../../../core/util.js";
+import { makeChainable } from "../../../common/make-chainable/index.js";
+import { idOf } from "./util/util.js";
+import { parseIntervals } from "./util/parse-intervals.js";
+import { parseGroupReferences } from "./util/parse-group-references.js";
+import { toDayAndStart } from "./events.js";
+import { groupBy, omitBy, uniq } from "lodash-es";
+
+//#region src/RS/to/input/dynamic-locked-times.ts
+function parse(lockedTime, settings, options) {
+	const duration = lockedTime.duration;
+	if (!duration || duration < 5) throw new Error("(RS::V3::To::DynamicLockedTimes) Length of a locked time is less than 5 min");
+	const dependencyReferences = makeChainable(lockedTime.coalesced ?? []).chain((x) => x.filter((x$1) => x$1.toModel == "locations").map((x$1) => getVertexId(x$1.to, options)), (x) => uniq(x), (x) => x.map((x$1) => [x$1])).value;
+	const days = lockedTime.intervals ? makeChainable(lockedTime.intervals).chain((x) => x.map((x$1) => getDayIndex(x$1.start)), (x) => uniq(x)).value : void 0;
+	const day = days?.length == 1 ? days[0] : void 0;
+	if (day != null && lockedTime.coalesced) {
+		const allowedByEvery = lockedTime.coalesced.every((x) => !x.to.days?.length || x.to.days.some((x$1) => x$1.day == day));
+		if (!allowedByEvery) return;
+	}
+	const distributionKey = lockedTime.type == "COMPLEMENTARY_TIME" ? "COMPLEMENTARY_TIME." + lockedTime.tags?.at(0)?.value : void 0;
+	const doc = {
+		id: idOf.lockedTime(lockedTime, options),
+		length: duration,
+		minBreakLength: false,
+		maxLengthVariance: lockedTime.durationVariance,
+		groups: parseGroupReferences({
+			type: "lockedTime",
+			item: lockedTime
+		}, options),
+		dependencies: dependencyReferences,
+		intervals: options.oldFormat ? parseIntervals(lockedTime.intervals, void 0, settings) : idOf.intervalPairReference(lockedTime.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.length = lockedTime.duration;
+				doc.maxLengthVariance = 0;
+				const numDays = settings.numDays ?? 5;
+				doc.days = Array.from({ length: numDays }, (_, i) => i);
+				doc.intervals = Array.from({ length: numDays }, () => [{
+					beg: 0,
+					end: 23.55
+				}]);
+			}
+		}
+	}
+	return omitBy(doc, (x) => x == null);
+}
+function fromDynamicLockedTimes(lockedTimes, settings, options) {
+	const complementaryHours = makeChainable(lockedTimes).chain((x) => x.filter((x$1) => x$1.type == "COMPLEMENTARY_TIME").map((x$1) => parse(x$1, settings, options)).filter((x$1) => !!x$1), (x) => groupBy(x, (x$1) => [x$1.distributionKey].flat().toSorted().join("|")), (x) => Object.entries(x).map(([id, events]) => ({
+		id,
+		events
+	}))).value;
+	const lunches = lockedTimes.filter((x) => x.type == "LUNCH").map((lockedTime) => parse(lockedTime, settings, options)).filter((x) => !!x);
+	return [...complementaryHours, ...lunches];
+}
+
+//#endregion
+export { fromDynamicLockedTimes };
+//# sourceMappingURL=dynamic-locked-times.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-locked-times.js","names":["x","doc: Types.event"],"sources":["../../../../src/RS/to/input/dynamic-locked-times.ts"],"sourcesContent":["import { groupBy, omitBy, uniq } from 'lodash-es';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getDayIndex, getVertexId } from '../../../core/util';\nimport { idOf } from './util/util';\nimport { parseGroupReferences } from './util/parse-group-references';\nimport { parseIntervals } from './util/parse-intervals';\nimport type { Types } from '../../types';\nimport { makeChainable } from '../../../common/make-chainable';\nimport { toDayAndStart } from './events';\n\nfunction parse (\n  lockedTime: ConnectedTypes.lockedTime,\n  settings:   ConnectedTypes.divisionSettings,\n  options:    Types.parsedToOptions,\n) {\n  const duration = lockedTime.duration;\n  if (!duration || duration < 5) throw new Error('(RS::V3::To::DynamicLockedTimes) Length of a locked time is less than 5 min');\n\n  const dependencyReferences = makeChainable(lockedTime.coalesced ?? [])\n    .chain(\n      x => x\n        .filter(x => x.toModel == 'locations')\n        .map(x => getVertexId(x.to, options)),\n      x => uniq(x),\n      x => x.map(x => [x])\n    )\n    .value;\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 doc: Types.event = {\n    id:                idOf.lockedTime(lockedTime, options),\n    length:            duration,\n    minBreakLength:    false,\n    maxLengthVariance: lockedTime.durationVariance,\n    groups:            parseGroupReferences({ type: 'lockedTime', item: lockedTime }, options),\n    dependencies:      dependencyReferences,\n    intervals:         options.oldFormat\n      ? parseIntervals(lockedTime.intervals, undefined, settings)\n      : idOf.intervalPairReference(lockedTime.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.length = lockedTime.duration;\n        doc.maxLengthVariance = 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 }, () => [{ beg: 0, end: 23.55 }]);\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.event;\n}\n\nexport function fromDynamicLockedTimes (\n  lockedTimes: ConnectedTypes.lockedTime[],\n  settings:    ConnectedTypes.divisionSettings,\n  options:     Types.parsedToOptions,\n): (Types.collection | Types.event)[] {\n\n  const complementaryHours = makeChainable(lockedTimes)\n    .chain(\n      x => x\n        .filter(x => x.type == 'COMPLEMENTARY_TIME')\n        .map(x => parse(x, settings, options))\n        .filter(x => !!x),\n      x => groupBy(x, x => [x.distributionKey].flat().toSorted().join('|')),\n      x => Object.entries(x)\n        .map(([id, events]) => ({ id, events }) as Types.collection),\n    )\n    .value;\n\n  const lunches = lockedTimes\n    .filter(x => x.type == 'LUNCH')\n    .map(lockedTime => parse(lockedTime, settings, options))\n    .filter(x => !!x);\n\n  return [...complementaryHours, ...lunches];\n};"],"mappings":";;;;;;;;;AAUA,SAAS,MACP,YACA,UACA,SACA;CACA,MAAM,WAAW,WAAW;AAC5B,KAAI,CAAC,YAAY,WAAW,EAAG,OAAM,IAAI,MAAM;CAE/C,MAAM,uBAAuB,cAAc,WAAW,aAAa,IAChE,OACC,MAAK,EACF,QAAO,QAAKA,IAAE,WAAW,aACzB,KAAI,QAAK,YAAYA,IAAE,IAAI,YAC9B,MAAK,KAAK,KACV,MAAK,EAAE,KAAI,QAAK,CAACA,OAElB;CAEH,MAAM,OAAO,WAAW,YACpB,cAAc,WAAW,WACxB,OACC,MAAK,EAAE,KAAI,QAAK,YAAYA,IAAE,UAC9B,MAAK,KAAK,IAEX,QACD;CACJ,MAAM,MAAM,MAAM,UAAU,IAAI,KAAK,KAAK;AAG1C,KAAI,OAAO,QAAQ,WAAW,WAAW;EACvC,MAAM,iBAAiB,WAAW,UAAU,OAAM,MAAK,CAAC,EAAE,GAAG,MAAM,UAAU,EAAE,GAAG,KAAK,MAAK,QAAKA,IAAE,OAAO;AAC1G,MAAI,CAAC,eAAgB;;CAIvB,MAAM,kBAAkB,WAAW,QAAQ,uBACvC,wBAAwB,WAAW,MAAM,GAAG,IAAI,QAChD;CAEJ,MAAMC,MAAmB;EACvB,IAAmB,KAAK,WAAW,YAAY;EAC/C,QAAmB;EACnB,gBAAmB;EACnB,mBAAmB,WAAW;EAC9B,QAAmB,qBAAqB;GAAE,MAAM;GAAc,MAAM;KAAc;EAClF,cAAmB;EACnB,WAAmB,QAAQ,YACvB,eAAe,WAAW,WAAW,QAAW,YAChD,KAAK,sBAAsB,WAAW,WAAW,QAAW;EAChE;EACA,GAAG,QAAQ,EAAE;EACb,GAAG,OAAO,EAAE;;AAOd,KAAI,QAAQ,wBAAwB;EAClC,MAAM,EAAE,gBAAgB,0BAA0B,QAAQ;AAC1D,MAAI,kBAAkB,CAAC,eAAe,IAAI,IAAI,KAAK;AAEjD,OAAI,yBAAyB,SAAU;AAEvC,OAAI,yBAAyB,UAAU;AAErC,QAAI,WAAW,UAAU,CAAC,WAAW,SAAS,CAAC,WAAW,SAAU;AAGpE,WAAO,OAAO,KAAK,cAAc,WAAW;AAC5C,QAAI,SAAS,WAAW;AACxB,QAAI,oBAAoB;IAGxB,MAAM,UAAU,SAAS,WAAW;AACpC,QAAI,OAAY,MAAM,KAAK,EAAE,QAAQ,YAAY,GAAG,MAAM;AAC1D,QAAI,YAAY,MAAM,KAAK,EAAE,QAAQ,iBAAiB,CAAC;KAAE,KAAK;KAAG,KAAK;;;;;AAQ5E,QAAO,OAAO,MAAK,MAAK,KAAK;;AAG/B,SAAgB,uBACd,aACA,UACA,SACoC;CAEpC,MAAM,qBAAqB,cAAc,aACtC,OACC,MAAK,EACF,QAAO,QAAKD,IAAE,QAAQ,sBACtB,KAAI,QAAK,MAAMA,KAAG,UAAU,UAC5B,QAAO,QAAK,CAAC,CAACA,OACjB,MAAK,QAAQ,IAAG,QAAK,CAACA,IAAE,iBAAiB,OAAO,WAAW,KAAK,QAChE,MAAK,OAAO,QAAQ,GACjB,KAAK,CAAC,IAAI,aAAa;EAAE;EAAI;MAEjC;CAEH,MAAM,UAAU,YACb,QAAO,MAAK,EAAE,QAAQ,SACtB,KAAI,eAAc,MAAM,YAAY,UAAU,UAC9C,QAAO,MAAK,CAAC,CAAC;AAEjB,QAAO,CAAC,GAAG,oBAAoB,GAAG"}

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

@@ -0,0 +1,84 @@
+import { getDayIndex, getVertexId } from "../../../core/util.js";
+import { getPeriodIndex, idOf } from "./util/util.js";
+import { attachLockedTimes } from "./util/attach-locked-times.js";
+import { parseDays } from "./util/parse-days.js";
+import { parseMinimumBreakLength } from "./util/parse-minimum-break-length.js";
+import { parseIntervals } from "./util/parse-intervals.js";
+import { parseGroupReferences } from "./util/parse-group-references.js";
+import { parseLocationReferences, parseSelectedLocations } from "./util/parse-location-references.js";
+import { omitBy } from "lodash-es";
+import moment from "moment";
+
+//#region src/RS/to/input/events.ts
+function toDayAndStart(start) {
+	return {
+		start: parseFloat(moment.utc(start).format("HH.mm")),
+		day: getDayIndex(start)
+	};
+}
+function parseEvents(events, settings, options, periodsMap) {
+	return (events ?? []).map((event) => {
+		const id = getVertexId(event, options);
+		const duration = event.preferredDuration ?? event.duration;
+		if (!duration) throw new Error(`(RS::V3::To::Events) Event "${id}" has no duration`);
+		const doc = {
+			id: idOf.event(event, options),
+			length: duration,
+			maxLengthVariance: event.durationVariance,
+			weight: event.weight,
+			density: event.density,
+			potentialCenter: event.centerOfAttraction ? parseFloat(event.centerOfAttraction.replace(":", ".")) : void 0,
+			forcedOverlapId: event.overlapSpecies?.species?.find(({ to }) => to == event)?.id,
+			period: getPeriodIndex(event.period, periodsMap, options),
+			days: parseDays(event.days, settings),
+			dependencies: parseLocationReferences(event.locations, options),
+			groups: parseGroupReferences({
+				type: "event",
+				item: event
+			}, options),
+			intervals: options.oldFormat ? parseIntervals(event.intervals, void 0, settings) : idOf.intervalPairReference(event.intervals, void 0, options),
+			lockedTimes: attachLockedTimes(event.lockedTimes, options),
+			minBreakLength: parseMinimumBreakLength(event.minBreakLength)
+		};
+		if (event.fixedStart && event.start) Object.assign(doc, toDayAndStart(event.start));
+		if (options.meta) doc.meta = omitBy({
+			name: event.displayName,
+			ids: event.ids,
+			parked: event.parked,
+			visible: event.visible,
+			start: event.start ? moment.utc(event.start) : void 0,
+			end: event.end ? moment.utc(event.start) : void 0,
+			course: event.course ? getVertexId(event.course, options) : void 0,
+			inLocations: event.inLocations ? parseSelectedLocations(event, options) : void 0
+		}, (x) => x == null);
+		if (options.partialScheduleOptions) {
+			const { includedEvents, omittedEventsHandling } = options.partialScheduleOptions;
+			if (includedEvents && !includedEvents.has(doc.id)) {
+				if (omittedEventsHandling == "ignore") return;
+				if (omittedEventsHandling == "freeze") {
+					if (event.parked || !event.start || !event.duration) return;
+					Object.assign(doc, toDayAndStart(event.start));
+					doc.length = event.duration;
+					doc.maxLengthVariance = 0;
+					const numDays = settings.numDays ?? 5;
+					doc.days = Array.from({ length: numDays }, (_, i) => i);
+					doc.intervals = Array.from({ length: numDays }, () => [{
+						beg: 0,
+						end: 23.55
+					}]);
+					doc.dependencies = (event.inLocations ?? []).filter((x) => !!x).map((x) => {
+						const id$1 = getVertexId(x, options);
+						const includedLocations = options.partialScheduleOptions?.includedLocations;
+						if (includedLocations && !includedLocations.has(id$1)) return;
+						return [{ dependency: id$1 }];
+					}).filter((x) => x != null);
+				}
+			}
+		}
+		return omitBy(doc, (x) => x == null);
+	}).filter((x) => !!x);
+}
+
+//#endregion
+export { parseEvents, toDayAndStart };
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":["doc: Types.event","id"],"sources":["../../../../src/RS/to/input/events.ts"],"sourcesContent":["import moment from 'moment';\nimport { omitBy } from 'lodash-es';\nimport { parseMinimumBreakLength } from './util/parse-minimum-break-length';\nimport { attachLockedTimes } from './util/attach-locked-times';\nimport type { Types } from '../../types';\nimport { parseGroupReferences } from './util/parse-group-references';\nimport { parseLocationReferences, parseSelectedLocations } from './util/parse-location-references';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getDayIndex, getVertexId } from '../../../core/util';\nimport { getPeriodIndex, idOf } from './util/util';\nimport { parseDays } from './util/parse-days';\nimport type { DateType } from '../../../common/types';\nimport { parseIntervals } from './util/parse-intervals';\n\nexport function toDayAndStart (start: DateType) {\n  return {\n    start: parseFloat(moment.utc(start).format('HH.mm')),\n    day:   getDayIndex(start)\n  };\n}\n\nexport function parseEvents (\n  events:     ConnectedTypes.event[] | undefined,\n  settings:   ConnectedTypes.divisionSettings,\n  options:    Types.parsedToOptions,\n  periodsMap: Map<string | undefined, number>\n): Types.event[] {\n\n  return (events ?? [])\n    .map((event): Types.event | undefined => {\n      const id = getVertexId(event, options);\n\n      const duration = event.preferredDuration ?? event.duration;  // temporary, should be preferred duration only!\n      if (!duration) throw new Error(`(RS::V3::To::Events) Event \"${id}\" has no duration`);\n\n      const doc: Types.event = {\n        id:                idOf.event(event, options),\n        length:            duration,\n        maxLengthVariance: event.durationVariance,\n        weight:            event.weight,\n        density:           event.density,\n        potentialCenter:   event.centerOfAttraction ? parseFloat(event.centerOfAttraction.replace(':', '.')) : undefined,\n        forcedOverlapId:   event.overlapSpecies?.species?.find(({ to }) => to == event)?.id,\n\n        period:       getPeriodIndex            (event.period, periodsMap, options),\n        days:         parseDays                 (event.days, settings),\n        dependencies: parseLocationReferences   (event.locations, options),\n        groups:       parseGroupReferences      ({ type: 'event', item: event }, options),\n        intervals:    options.oldFormat\n          ? parseIntervals(event.intervals, undefined, settings)\n          : idOf.intervalPairReference(event.intervals, undefined, options),\n        lockedTimes:    attachLockedTimes         (event.lockedTimes, options),\n        minBreakLength: parseMinimumBreakLength   (event.minBreakLength),\n      };\n\n      // if the event has a fixed day and start\n      if (event.fixedStart && event.start) {\n        Object.assign(doc, toDayAndStart(event.start));\n      }\n\n      if (options.meta) {\n        doc.meta = omitBy({\n          name:        event.displayName,\n          ids:         event.ids,\n          parked:      event.parked,\n          visible:     event.visible,\n          start:       event.start       ? moment.utc(event.start)                : undefined,\n          end:         event.end         ? moment.utc(event.start)                : undefined,\n          course:      event.course      ? getVertexId(event.course, options)     : undefined,\n          inLocations: event.inLocations ? parseSelectedLocations(event, options) : undefined\n        }, x => x == null);\n      }\n\n      ////\n      //// filter events based on partialScheduleOptions\n      ////\n      if (options.partialScheduleOptions) {\n        const { includedEvents, omittedEventsHandling } = options.partialScheduleOptions;\n        if (includedEvents && !includedEvents.has(doc.id)) {  // collection.id  => take into account dynamic locked times too!\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 (event.parked || !event.start || !event.duration) return;\n\n            // fix day, start and end\n            Object.assign(doc, toDayAndStart(event.start));\n            doc.length = event.duration;\n            doc.maxLengthVariance = 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 }, () => [{ beg: 0, end: 23.55 }]);\n\n            // fix locations\n            doc.dependencies = (event.inLocations ?? [])\n              .filter((x): x is NonNullable<typeof x> => !!x)\n              .map(x => {\n                const id = getVertexId(x, options);\n\n                // filter location references based on partial schedule options\n                const includedLocations = options.partialScheduleOptions?.includedLocations;\n                if (includedLocations && !includedLocations.has(id)) return;\n\n                return [{ dependency: id }] as Types.availableDependency[];\n              })\n              .filter(x => x != null);\n          }\n\n        }\n      }\n\n      return omitBy(doc, x => x == null) as Types.event;\n    })\n    .filter((x): x is NonNullable<typeof x> => !!x);\n}"],"mappings":";;;;;;;;;;;;AAcA,SAAgB,cAAe,OAAiB;AAC9C,QAAO;EACL,OAAO,WAAW,OAAO,IAAI,OAAO,OAAO;EAC3C,KAAO,YAAY;;;AAIvB,SAAgB,YACd,QACA,UACA,SACA,YACe;AAEf,SAAQ,UAAU,IACf,KAAK,UAAmC;EACvC,MAAM,KAAK,YAAY,OAAO;EAE9B,MAAM,WAAW,MAAM,qBAAqB,MAAM;AAClD,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,+BAA+B,GAAG;EAEjE,MAAMA,MAAmB;GACvB,IAAmB,KAAK,MAAM,OAAO;GACrC,QAAmB;GACnB,mBAAmB,MAAM;GACzB,QAAmB,MAAM;GACzB,SAAmB,MAAM;GACzB,iBAAmB,MAAM,qBAAqB,WAAW,MAAM,mBAAmB,QAAQ,KAAK,QAAQ;GACvG,iBAAmB,MAAM,gBAAgB,SAAS,MAAM,EAAE,SAAS,MAAM,QAAQ;GAEjF,QAAc,eAA2B,MAAM,QAAQ,YAAY;GACnE,MAAc,UAA2B,MAAM,MAAM;GACrD,cAAc,wBAA2B,MAAM,WAAW;GAC1D,QAAc,qBAA2B;IAAE,MAAM;IAAS,MAAM;MAAS;GACzE,WAAc,QAAQ,YAClB,eAAe,MAAM,WAAW,QAAW,YAC3C,KAAK,sBAAsB,MAAM,WAAW,QAAW;GAC3D,aAAgB,kBAA2B,MAAM,aAAa;GAC9D,gBAAgB,wBAA2B,MAAM;;AAInD,MAAI,MAAM,cAAc,MAAM,MAC5B,QAAO,OAAO,KAAK,cAAc,MAAM;AAGzC,MAAI,QAAQ,KACV,KAAI,OAAO,OAAO;GAChB,MAAa,MAAM;GACnB,KAAa,MAAM;GACnB,QAAa,MAAM;GACnB,SAAa,MAAM;GACnB,OAAa,MAAM,QAAc,OAAO,IAAI,MAAM,SAAwB;GAC1E,KAAa,MAAM,MAAc,OAAO,IAAI,MAAM,SAAwB;GAC1E,QAAa,MAAM,SAAc,YAAY,MAAM,QAAQ,WAAe;GAC1E,aAAa,MAAM,cAAc,uBAAuB,OAAO,WAAW;MACzE,MAAK,KAAK;AAMf,MAAI,QAAQ,wBAAwB;GAClC,MAAM,EAAE,gBAAgB,0BAA0B,QAAQ;AAC1D,OAAI,kBAAkB,CAAC,eAAe,IAAI,IAAI,KAAK;AAEjD,QAAI,yBAAyB,SAAU;AAEvC,QAAI,yBAAyB,UAAU;AAErC,SAAI,MAAM,UAAU,CAAC,MAAM,SAAS,CAAC,MAAM,SAAU;AAGrD,YAAO,OAAO,KAAK,cAAc,MAAM;AACvC,SAAI,SAAS,MAAM;AACnB,SAAI,oBAAoB;KAGxB,MAAM,UAAU,SAAS,WAAW;AACpC,SAAI,OAAY,MAAM,KAAK,EAAE,QAAQ,YAAY,GAAG,MAAM;AAC1D,SAAI,YAAY,MAAM,KAAK,EAAE,QAAQ,iBAAiB,CAAC;MAAE,KAAK;MAAG,KAAK;;AAGtE,SAAI,gBAAgB,MAAM,eAAe,IACtC,QAAQ,MAAkC,CAAC,CAAC,GAC5C,KAAI,MAAK;MACR,MAAMC,OAAK,YAAY,GAAG;MAG1B,MAAM,oBAAoB,QAAQ,wBAAwB;AAC1D,UAAI,qBAAqB,CAAC,kBAAkB,IAAIA,MAAK;AAErD,aAAO,CAAC,EAAE,YAAYA;QAEvB,QAAO,MAAK,KAAK;;;;AAM1B,SAAO,OAAO,MAAK,MAAK,KAAK;IAE9B,QAAQ,MAAkC,CAAC,CAAC"}

package/dist/RS/to/input/groups.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/groups.ts
+function fromGroups(groups, settings, options) {
+	return groups.filter((group) => group.species == "class").map((group) => {
+		const doc = {
+			id: idOf.group(group, options),
+			group_type: "classes",
+			weight: group.weight,
+			minimizeGaps: true,
+			minimizeDependencyAlternation: false,
+			forbidOverlappingEvents: options.oldFormat ? group.forbidOverlappingEvents : void 0,
+			disableDayLengthPunishment: options.oldFormat ? group.disableDayLengthPunishment : void 0,
+			intervals: options.oldFormat ? parseIntervals(group.intervals, group.rootInterval ?? settings.defaultRootInterval, settings) : idOf.intervalPairReference(group.intervals, group.rootInterval, options),
+			days: parseDays(group.days, settings),
+			lockedTimes: attachLockedTimes(group.lockedTimes, options),
+			minBreakLength: parseMinimumBreakLength(group.minBreakLength),
+			...parseMaxWorkingHours(group, options)
+		};
+		if (options.meta) doc.meta = omitBy({
+			ids: group.ids,
+			name: group.displayName
+		}, (x) => x == null);
+		return omitBy(doc, (x) => x == null);
+	});
+}
+
+//#endregion
+export { fromGroups };
+//# sourceMappingURL=groups.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groups.js","names":["doc: Types.group"],"sources":["../../../../src/RS/to/input/groups.ts"],"sourcesContent":["import { omitBy } from 'lodash-es';\nimport type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { parseDays } from './util/parse-days';\nimport { attachLockedTimes } from './util/attach-locked-times';\nimport { parseMinimumBreakLength } from './util/parse-minimum-break-length';\nimport { parseMaxWorkingHours } from './util/parse-max-working-hours';\nimport { idOf } from './util/util';\nimport { parseIntervals } from './util/parse-intervals';\n\nexport function fromGroups (\n  groups:   ConnectedTypes.group[],\n  settings: ConnectedTypes.divisionSettings,\n  options:  Types.parsedToOptions\n): Types.group[] {\n\n  return groups\n    .filter(group => group.species == 'class')\n    .map(group => {\n      const doc: Types.group = {\n        id:                            idOf.group(group, options),\n        group_type:                    'classes',\n        weight:                        group.weight,\n        minimizeGaps:                  true,\n        minimizeDependencyAlternation: false,\n        forbidOverlappingEvents:       options.oldFormat ? group.forbidOverlappingEvents : undefined,  // Deprecated in v3\n        disableDayLengthPunishment:    options.oldFormat ? group.disableDayLengthPunishment : undefined,  // Deprecated in v3\n        intervals:                     options.oldFormat\n          ? parseIntervals(group.intervals, group.rootInterval ?? settings.defaultRootInterval, settings)\n          : idOf.intervalPairReference(group.intervals, group.rootInterval, options),\n        days:           parseDays                 (group.days, settings),\n        lockedTimes:    attachLockedTimes         (group.lockedTimes, options),\n        minBreakLength: parseMinimumBreakLength   (group.minBreakLength),\n\n        ...parseMaxWorkingHours(group, options),\n      };\n\n      if (options.meta) {\n        doc.meta = omitBy({\n          ids:  group.ids,\n          name: group.displayName,\n        }, x => x == null);\n      }\n\n      return omitBy(doc, x => x == null) as Types.group;\n    });\n};\n"],"mappings":";;;;;;;;;AAUA,SAAgB,WACd,QACA,UACA,SACe;AAEf,QAAO,OACJ,QAAO,UAAS,MAAM,WAAW,SACjC,KAAI,UAAS;EACZ,MAAMA,MAAmB;GACvB,IAA+B,KAAK,MAAM,OAAO;GACjD,YAA+B;GAC/B,QAA+B,MAAM;GACrC,cAA+B;GAC/B,+BAA+B;GAC/B,yBAA+B,QAAQ,YAAY,MAAM,0BAA0B;GACnF,4BAA+B,QAAQ,YAAY,MAAM,6BAA6B;GACtF,WAA+B,QAAQ,YACnC,eAAe,MAAM,WAAW,MAAM,gBAAgB,SAAS,qBAAqB,YACpF,KAAK,sBAAsB,MAAM,WAAW,MAAM,cAAc;GACpE,MAAgB,UAA2B,MAAM,MAAM;GACvD,aAAgB,kBAA2B,MAAM,aAAa;GAC9D,gBAAgB,wBAA2B,MAAM;GAEjD,GAAG,qBAAqB,OAAO;;AAGjC,MAAI,QAAQ,KACV,KAAI,OAAO,OAAO;GAChB,KAAM,MAAM;GACZ,MAAM,MAAM;MACX,MAAK,KAAK;AAGf,SAAO,OAAO,MAAK,MAAK,KAAK"}

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

@@ -0,0 +1,49 @@
+import { getVertexId } from "../../../core/util.js";
+import { makeChainable } from "../../../common/make-chainable/index.js";
+import { idOf } from "./util/util.js";
+import { omitBy, uniqBy } from "lodash-es";
+
+//#region src/RS/to/input/individuals.ts
+function fromPersonsToIndividuals(persons, options) {
+	return persons.map((person) => {
+		const doc = {
+			id: idOf.person(person, options),
+			group: person.group ? `groups.${getVertexId(person.group, options)}` : void 0
+		};
+		if (options.meta) doc.meta = omitBy({
+			ids: person.ids,
+			name: person.displayName
+		}, (x) => x == null);
+		return omitBy(doc, (x) => x == null);
+	});
+}
+function fromGroupToIndividualsSet(id, reference, options) {
+	const members = new Set(reference.to.members?.map((x) => getVertexId(x, options)));
+	const excluded = new Set(reference.exclude?.map((x) => getVertexId(x, options)));
+	const remaining = members.difference(excluded);
+	const doc = {
+		id,
+		individuals: [...remaining].map((x) => idOf.person(x, options))
+	};
+	if (options.meta) doc.meta = omitBy({ name: reference.to.displayName + (reference.exclude?.length ? ` (excl. ${reference.exclude.map((x) => x.displayName).join(", ")})` : "") }, (x) => x == null);
+	return doc;
+}
+function extractUniqueIndividuals(persons, courses, events, lockedTimes, options) {
+	const individuals = fromPersonsToIndividuals(persons, options);
+	const uniqueIndividualsSetsFromGroupReferences = makeChainable([
+		...courses,
+		...events,
+		...lockedTimes
+	]).chain((x) => x.map((item) => {
+		if ("groups" in item) return item.groups;
+		if ("coalesced" in item) return item.coalesced?.filter((x$1) => x$1.toModel == "groups").map((x$1) => ({ to: x$1.to }));
+	}).flatMap((references) => (references ?? []).filter((x$1) => x$1.to.species != "class" || x$1.exclude?.length).map((x$1) => ({
+		id: idOf.groupReference(x$1, options),
+		value: x$1
+	}))), (x) => uniqBy(x, (x$1) => x$1.id).map((x$1) => fromGroupToIndividualsSet(x$1.id, x$1.value, options))).value;
+	return individuals.concat(uniqueIndividualsSetsFromGroupReferences);
+}
+
+//#endregion
+export { extractUniqueIndividuals };
+//# sourceMappingURL=individuals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"individuals.js","names":["doc: Types.individual","doc: Types.individualsSet","x"],"sources":["../../../../src/RS/to/input/individuals.ts"],"sourcesContent":["import { omitBy, uniqBy } from 'lodash-es';\nimport type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getVertexId } from '../../../core/util';\nimport type { Coalesced, GroupReference } from '../../../core/types/common';\nimport { idOf } from './util/util';\nimport { makeChainable } from '../../../common/make-chainable';\n\n\nfunction fromPersonsToIndividuals (\n  persons:  ConnectedTypes.person[],\n  options:  Types.parsedToOptions\n): Types.individual[] {\n  return persons.map(person => {\n    const doc: Types.individual = {\n      id:    idOf.person(person, options),\n      group: person.group ? `groups.${ getVertexId(person.group, options) }` : undefined,\n    };\n\n    if (options.meta) {\n      doc.meta = omitBy({\n        ids:  person.ids,\n        name: person.displayName,\n      }, x => x == null);\n    }\n\n    return omitBy(doc, x => x == null) as Types.individual;\n  });\n}\n\nfunction fromGroupToIndividualsSet (\n  id:        string,\n  reference: GroupReference<ConnectedTypes.group, ConnectedTypes.person>,\n  options:   Types.parsedToOptions\n): Types.individualsSet {\n  const members   = new Set(reference.to.members?.map(x => getVertexId(x, options)));\n  const excluded  = new Set(reference.exclude?.map(x => getVertexId(x, options)));\n  const remaining = members.difference(excluded);\n\n  const doc: Types.individualsSet = {\n    id:          id,\n    individuals: [...remaining].map(x => idOf.person(x, options)),\n  };\n\n  if (options.meta) {\n    doc.meta = omitBy({\n      name: reference.to.displayName + (reference.exclude?.length ? ` (excl. ${ reference.exclude.map(x => x.displayName).join(', ') })` : ''),\n    }, x => x == null);\n  }\n\n  return doc;\n}\n\n// function fromParticipantsToIndividualsSet (\n//   id:        string,\n//   reference: PersonReference<ConnectedTypes.person>[],\n//   options:   OutOptions\n// ): _IndividualsSet {\n//   const idKey = getIdKey(options);\n\n//   const doc: _IndividualsSet = {\n//     id:          id,\n//     individuals: reference.map(x => getVertexId(x.to, idKey))\n//   };\n\n//   if (options.meta) {\n//     doc.meta = omitBy({\n//       name: reference.map(x => x.to.displayName).join(', '),\n//     }, x => x == null);\n//   }\n\n//   return doc;\n// }\n\nexport function extractUniqueIndividuals (\n  persons:     ConnectedTypes.person[],\n  courses:     ConnectedTypes.course[],\n  events:      ConnectedTypes.event[],\n  lockedTimes: ConnectedTypes.lockedTime[],\n  options:     Types.parsedToOptions\n): (Types.individual | Types.individualsSet)[] {\n  const individuals = fromPersonsToIndividuals(persons, options);\n\n  const uniqueIndividualsSetsFromGroupReferences = makeChainable([...courses, ...events, ...lockedTimes])\n    .chain(\n      x => x\n        .map(item => {\n          if ('groups'    in item) return item.groups;   // we may ignore the parent groups as they are all plain group references\n          if ('coalesced' in item) return item.coalesced\n            ?.filter((x): x is Coalesced<ConnectedTypes.group, 'groups'> => x.toModel == 'groups')\n            .map((x): GroupReference<ConnectedTypes.group, ConnectedTypes.person> => ({ to: x.to }));\n          return;\n        })\n        .flatMap(references => (references ?? [])\n          .filter(x => x.to.species != 'class' || x.exclude?.length)   // if plain group reference we will use the group directly\n          .map(x => ({ id: idOf.groupReference(x, options), value: x }))\n        ),\n      x => uniqBy(x, x => x.id)\n        .map(x => fromGroupToIndividualsSet(x.id, x.value, options))\n    )\n    .value;\n\n  ////\n  ////   NOT NEEDED AS WE USE THE INDIVIDUALS DIRECTLY\n  ////\n  // const uniqueIndividualsSetsFromParticipants = chain([...courses, ...events])\n  //   .map(item => {\n  //     if ('participants' in item) return item.participants;\n  //     return;\n  //   })\n  //   .filter(x => x != null)\n  //   .filter(x => x.length > 1)   // if a single participant we will use the individual directly\n  //   .map(x => ({ id: idOf.participantsReference(x, options), value: x }))\n  //   .uniqBy(x => x.id)\n  //   .map(x => fromParticipantsToIndividualsSet(x.id, x.value, options))\n  //   .value();\n\n  return individuals\n    .concat(uniqueIndividualsSetsFromGroupReferences);\n  // .concat(uniqueIndividualsSetsFromParticipants);\n};\n"],"mappings":";;;;;;AASA,SAAS,yBACP,SACA,SACoB;AACpB,QAAO,QAAQ,KAAI,WAAU;EAC3B,MAAMA,MAAwB;GAC5B,IAAO,KAAK,OAAO,QAAQ;GAC3B,OAAO,OAAO,QAAQ,UAAW,YAAY,OAAO,OAAO,aAAc;;AAG3E,MAAI,QAAQ,KACV,KAAI,OAAO,OAAO;GAChB,KAAM,OAAO;GACb,MAAM,OAAO;MACZ,MAAK,KAAK;AAGf,SAAO,OAAO,MAAK,MAAK,KAAK;;;AAIjC,SAAS,0BACP,IACA,WACA,SACsB;CACtB,MAAM,UAAY,IAAI,IAAI,UAAU,GAAG,SAAS,KAAI,MAAK,YAAY,GAAG;CACxE,MAAM,WAAY,IAAI,IAAI,UAAU,SAAS,KAAI,MAAK,YAAY,GAAG;CACrE,MAAM,YAAY,QAAQ,WAAW;CAErC,MAAMC,MAA4B;EACnB;EACb,aAAa,CAAC,GAAG,WAAW,KAAI,MAAK,KAAK,OAAO,GAAG;;AAGtD,KAAI,QAAQ,KACV,KAAI,OAAO,OAAO,EAChB,MAAM,UAAU,GAAG,eAAe,UAAU,SAAS,SAAS,WAAY,UAAU,QAAQ,KAAI,MAAK,EAAE,aAAa,KAAK,MAAO,KAAK,QACpI,MAAK,KAAK;AAGf,QAAO;;AAwBT,SAAgB,yBACd,SACA,SACA,QACA,aACA,SAC6C;CAC7C,MAAM,cAAc,yBAAyB,SAAS;CAEtD,MAAM,2CAA2C,cAAc;EAAC,GAAG;EAAS,GAAG;EAAQ,GAAG;IACvF,OACC,MAAK,EACF,KAAI,SAAQ;AACX,MAAI,YAAe,KAAM,QAAO,KAAK;AACrC,MAAI,eAAe,KAAM,QAAO,KAAK,WACjC,QAAQ,QAAsDC,IAAE,WAAW,UAC5E,KAAK,SAAoE,EAAE,IAAIA,IAAE;IAGrF,SAAQ,gBAAe,cAAc,IACnC,QAAO,QAAKA,IAAE,GAAG,WAAW,WAAWA,IAAE,SAAS,QAClD,KAAI,SAAM;EAAE,IAAI,KAAK,eAAeA,KAAG;EAAU,OAAOA;QAE7D,MAAK,OAAO,IAAG,QAAKA,IAAE,IACnB,KAAI,QAAK,0BAA0BA,IAAE,IAAIA,IAAE,OAAO,WAEtD;AAiBH,QAAO,YACJ,OAAO"}

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

@@ -0,0 +1,40 @@
+import { fromLocations } from "./dependencies.js";
+import { fromTeachers } from "./teachers.js";
+import { fromCollections } from "./collections.js";
+import { parseSettings } from "./settings.js";
+import { extractUniqueIntervals } from "./intervals.js";
+import { parseDefault } from "./default.js";
+import { fromDynamicLockedTimes } from "./dynamic-locked-times.js";
+import { parsePeriods } from "./periods.js";
+import { fromGroups } from "./groups.js";
+import { extractUniqueIndividuals } from "./individuals.js";
+
+//#region src/RS/to/input/input.ts
+function parseInput(schedule, options = {}) {
+	const settings = schedule.settings;
+	const division = schedule.division;
+	const groups = schedule.groups ?? [];
+	const teachers = schedule.teachers ?? [];
+	const locations = schedule.locations ?? [];
+	const events = schedule.events ?? [];
+	const lockedTimes = schedule.lockedTimes ?? [];
+	const courses = schedule.courses ?? [];
+	const periods = schedule.periods ?? [];
+	const persons = schedule.persons ?? [];
+	const { map: periodsMap, matrix: periodsMatrix } = parsePeriods(periods, division, options);
+	const data = {
+		settings: parseSettings(settings),
+		default: parseDefault(settings, periodsMap, options),
+		periods: periodsMatrix?.length ? periodsMatrix : void 0,
+		intervals: options.oldFormat ? void 0 : extractUniqueIntervals(settings, groups, teachers, courses, events, lockedTimes, options),
+		dependencies: fromLocations(locations, settings, options),
+		groups: fromGroups(groups, settings, options).concat(fromTeachers(teachers, settings, options)),
+		individuals: options.oldFormat ? void 0 : extractUniqueIndividuals(persons, courses, events, lockedTimes, options),
+		events: new Array().concat(fromCollections(courses, settings, options, periodsMap)).concat(fromDynamicLockedTimes(lockedTimes, settings, options))
+	};
+	return data;
+}
+
+//#endregion
+export { parseInput };
+//# sourceMappingURL=input.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input.js","names":["data: Types.scheduleData"],"sources":["../../../../src/RS/to/input/input.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport { fromLocations } from './dependencies';\nimport { fromTeachers } from './teachers';\nimport { fromCollections } from './collections';\nimport { parseSettings } from './settings';\nimport { parseDefault } from './default';\nimport { fromDynamicLockedTimes } from './dynamic-locked-times';\nimport { parsePeriods } from './periods';\nimport type { ConnectedScheduleData } from '../../make-connected';\nimport { fromGroups } from './groups';\nimport { extractUniqueIntervals } from './intervals';\nimport { extractUniqueIndividuals } from './individuals';\n\nexport function parseInput (\n  schedule: ConnectedScheduleData,\n  options:  Types.parsedToOptions = {}\n): Types.scheduleData {\n\n  const settings      = schedule.settings;\n  const division      = schedule.division;\n  const groups        = schedule.groups        ?? [];\n  const teachers      = schedule.teachers      ?? [];\n  const locations     = schedule.locations     ?? [];\n  const events        = schedule.events        ?? [];\n  const lockedTimes   = schedule.lockedTimes   ?? [];\n  const courses       = schedule.courses       ?? [];\n  const periods       = schedule.periods       ?? [];\n  const persons       = schedule.persons       ?? [];\n\n  const { map: periodsMap, matrix: periodsMatrix } = parsePeriods(periods, division, options);\n\n  const data: Types.scheduleData = {\n    settings: parseSettings(settings),\n    default:  parseDefault (settings, periodsMap, options),\n\n    periods: periodsMatrix?.length ? periodsMatrix : undefined, // cannot be empty string\n\n    intervals: options.oldFormat ? undefined : extractUniqueIntervals(settings, groups, teachers, courses, events, lockedTimes, options),\n\n    dependencies: fromLocations(locations, settings, options),\n\n    groups: fromGroups(groups, settings, options)\n      .concat(fromTeachers(teachers, settings, options)),\n\n    individuals: options.oldFormat ? undefined : extractUniqueIndividuals(persons, courses, events, lockedTimes, options),\n\n    events: new Array<Types.collection | Types.collection[] | Types.event[]>()\n      .concat(fromCollections(courses, settings, options, periodsMap))\n      .concat(fromDynamicLockedTimes(lockedTimes, settings, options)),\n  };\n\n  return data;\n};"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,WACd,UACA,UAAkC,IACd;CAEpB,MAAM,WAAgB,SAAS;CAC/B,MAAM,WAAgB,SAAS;CAC/B,MAAM,SAAgB,SAAS,UAAiB;CAChD,MAAM,WAAgB,SAAS,YAAiB;CAChD,MAAM,YAAgB,SAAS,aAAiB;CAChD,MAAM,SAAgB,SAAS,UAAiB;CAChD,MAAM,cAAgB,SAAS,eAAiB;CAChD,MAAM,UAAgB,SAAS,WAAiB;CAChD,MAAM,UAAgB,SAAS,WAAiB;CAChD,MAAM,UAAgB,SAAS,WAAiB;CAEhD,MAAM,EAAE,KAAK,YAAY,QAAQ,kBAAkB,aAAa,SAAS,UAAU;CAEnF,MAAMA,OAA2B;EAC/B,UAAU,cAAc;EACxB,SAAU,aAAc,UAAU,YAAY;EAE9C,SAAS,eAAe,SAAS,gBAAgB;EAEjD,WAAW,QAAQ,YAAY,SAAY,uBAAuB,UAAU,QAAQ,UAAU,SAAS,QAAQ,aAAa;EAE5H,cAAc,cAAc,WAAW,UAAU;EAEjD,QAAQ,WAAW,QAAQ,UAAU,SAClC,OAAO,aAAa,UAAU,UAAU;EAE3C,aAAa,QAAQ,YAAY,SAAY,yBAAyB,SAAS,SAAS,QAAQ,aAAa;EAE7G,QAAQ,IAAI,QACT,OAAO,gBAAgB,SAAS,UAAU,SAAS,aACnD,OAAO,uBAAuB,aAAa,UAAU;;AAG1D,QAAO"}

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

@@ -0,0 +1,99 @@
+import { getDayIndex } from "../../../core/util.js";
+import { makeChainable } from "../../../common/make-chainable/index.js";
+import { idOf } from "./util/util.js";
+import { groupBy, uniqBy } from "lodash-es";
+import moment from "moment";
+
+//#region src/RS/to/input/intervals.ts
+/**
+* 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 = moment.utc(i.start, "HH:mm");
+		const end = moment.utc(i.end, "HH:mm");
+		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::V3::To::convertIntervals) Interval missing start or end for day ${day}: ${JSON.stringify(i)}`);
+		const start = parseFloat(moment.utc(i.start).format("HH.mm"));
+		const end = parseFloat(moment.utc(i.end).format("HH.mm"));
+		return {
+			beg: start,
+			end
+		};
+	});
+}
+/**
+* Converts
+*/
+function combineAndMapIntervals(_intervals, rootInterval, settings) {
+	const intervals = toFloatIntervals(standardizeIntervals(_intervals, settings));
+	if (rootInterval) {
+		if (!intervals) throw new Error("(RS::V3::To::parseIntervals) 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::V3::To::Intervals) Day ${day} not found in dayStartAndEnds`);
+			return is.map((i) => ({
+				beg: parseFloat(moment.utc(i.start).format("HH.mm")),
+				end: parseFloat(moment.utc(i.end).format("HH.mm")),
+				binary: true
+			})).filter((i) => i.beg >= limits.beg && i.end <= limits.end);
+		})).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::V3::To::getDefaultInterval) \"settings.dayStart\" is falsy");
+	if (!dayEnd) throw new Error("(RS::V3::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 = new Array().concat(groups, teachers).map((item) => ({
+		id: idOf.intervalPairReference(item.intervals, item.rootIntervals, options),
+		data: [item.intervals ?? defaultInterval, item.rootIntervals ?? settings.defaultRootInterval]
+	}));
+	const withoutRootIntervals = new Array().concat({ intervals: defaultInterval }, courses, events, lockedTimes).map((item) => ({
+		id: idOf.intervalPairReference(item.intervals, void 0, options),
+		data: [item.intervals ?? defaultInterval, void 0]
+	}));
+	return makeChainable(withRootIntervals).chain((x) => x.concat(withoutRootIntervals), (x) => uniqBy(x, (x$1) => x$1.id), (x) => x.map(({ id, data: [_intervals, rootInterval] }) => {
+		const value = combineAndMapIntervals(_intervals, rootInterval, settings);
+		if (!value) return;
+		return {
+			id,
+			value
+		};
+	}).filter((x$1) => x$1 != null)).value;
+}
+
+//#endregion
+export { computesDefaultIntervalId, extractUniqueIntervals, getDefaultInterval };
+//# sourceMappingURL=intervals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intervals.js","names":["x"],"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 type { AllowedInterval } from '../../../core/types/common/intervals';\nimport { idOf } from './util/util';\nimport { getDayIndex } from '../../../core/util';\nimport type { DateType } from '../../../common/types';\nimport type { RootInterval } from '../../../core/types/root-intervals';\nimport { makeChainable } from '../../../common/make-chainable';\n\n/**\n * Removes the shorthand notation (a single day to represent all days)\n */\nfunction standardizeIntervals (\n  intervals:     AllowedInterval[] | undefined,\n  settings:      ConnectedTypes.divisionSettings\n): AllowedInterval[] | undefined {\n  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    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: AllowedInterval[] | undefined\n): { beg: number, end: number }[] | undefined {\n  return intervals?.map((i, day: number) => {\n    if (!i.start || !i.end) throw new Error(`(RS::V3::To::convertIntervals) Interval missing start or end for day ${day}: ${JSON.stringify(i)}`);\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 * Converts\n */\nfunction combineAndMapIntervals (\n  _intervals:    AllowedInterval[]           | undefined,\n  rootInterval:  ConnectedTypes.rootInterval | undefined,\n  settings:      ConnectedTypes.divisionSettings\n): Types.interval[][] | undefined {\n  const intervals = toFloatIntervals(standardizeIntervals(_intervals, settings));\n\n  if (rootInterval) {\n    if (!intervals) throw new Error('(RS::V3::To::parseIntervals) 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::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 is\n              .map(i => ({\n                beg:    parseFloat(moment.utc(i.start).format('HH.mm')),\n                end:    parseFloat(moment.utc(i.end  ).format('HH.mm')),\n                binary: true\n              } satisfies Types.interval))\n              .filter(i => i.beg >= limits.beg && i.end <= limits.end);\n          })\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): AllowedInterval[] {\n  const { dayStart, dayEnd } = settings;\n  if (!dayStart) throw new Error('(RS::V3::To::getDefaultInterval) \"settings.dayStart\" is falsy');\n  if (!dayEnd  ) throw new Error('(RS::V3::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.rootInterval[] {\n  const defaultInterval = getDefaultInterval(settings);\n\n  type Item            = { intervals?: AllowedInterval[]; rootIntervals?: ConnectedTypes.rootInterval };\n  type InheritedWithId = { id: string, data: [AllowedInterval<DateType>[] | undefined, RootInterval | undefined] };\n\n  // apply interval inheritance to the entities carrying root intervals\n  const withRootIntervals = new Array<Item>()\n    .concat(groups, teachers)\n    .map((item): InheritedWithId => ({\n      id:   idOf.intervalPairReference(item.intervals, item.rootIntervals, options),\n      data: [\n        item.intervals     ?? defaultInterval,\n        item.rootIntervals ?? settings.defaultRootInterval\n      ]\n    }));\n\n  const withoutRootIntervals = new Array<Item>()\n    .concat({ intervals: defaultInterval }, courses, events, lockedTimes)\n    .map((item): InheritedWithId => ({\n      id:   idOf.intervalPairReference(item.intervals, undefined, options),\n      data: [\n        item.intervals ?? defaultInterval,\n        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.rootInterval>;\n        })\n        .filter(x => x != null)\n    )\n    .value;\n};\n"],"mappings":";;;;;;;;;;AAcA,SAAS,qBACP,WACA,UAC+B;AAC/B,KAAI,WAAW,UAAU,GAAG;EAC1B,MAAM,IAAI,UAAU;EACpB,MAAM,QAAQ,OAAO,IAAI,EAAE,OAAO;EAClC,MAAM,MAAQ,OAAO,IAAI,EAAE,KAAO;AAClC,SAAO,MAAM,KAAK,EAAE,QAAQ,SAAS,kBAAkB;GAAE,OAAO,MAAM;GAAS,KAAK,IAAI;;;AAG1F,QAAO;;;;;AAMT,SAAS,iBACP,WAC4C;AAC5C,QAAO,WAAW,KAAK,GAAG,QAAgB;AACxC,MAAI,CAAC,EAAE,SAAS,CAAC,EAAE,IAAK,OAAM,IAAI,MAAM,wEAAwE,IAAI,IAAI,KAAK,UAAU;EACvI,MAAM,QAAQ,WAAW,OAAO,IAAI,EAAE,OAAO,OAAO;EACpD,MAAM,MAAQ,WAAW,OAAO,IAAI,EAAE,KAAO,OAAO;AACpD,SAAO;GAAE,KAAK;GAAY;;;;;;;AAO9B,SAAS,uBACP,YACA,cACA,UACgC;CAChC,MAAM,YAAY,iBAAiB,qBAAqB,YAAY;AAEpE,KAAI,cAAc;AAChB,MAAI,CAAC,UAAW,OAAM,IAAI,MAAM;AAChC,SAAO,cAAc,aAAa,WAC/B,OACC,MAAK,QAAQ,IAAG,MAAK,YAAY,EAAE,UACnC,MAAK,OAAO,QAAQ,GACjB,KAAK,CAAC,KAAK,QAAQ;GAClB,MAAM,SAAS,UAAU,GAAG,SAAS;AACrC,OAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,+BAA+B,IAAI;AAGhE,UAAO,GACJ,KAAI,OAAM;IACT,KAAQ,WAAW,OAAO,IAAI,EAAE,OAAO,OAAO;IAC9C,KAAQ,WAAW,OAAO,IAAI,EAAE,KAAO,OAAO;IAC9C,QAAQ;OAET,QAAO,MAAK,EAAE,OAAO,OAAO,OAAO,EAAE,OAAO,OAAO;MAG3D;;AAEL,KAAI,UACF,QAAO,UAAU,KAAI,MAAK,CAAC;;;;;AAQ/B,SAAgB,mBAAoB,UAA8D;CAChG,MAAM,EAAE,UAAU,WAAW;AAC7B,KAAI,CAAC,SAAU,OAAM,IAAI,MAAM;AAC/B,KAAI,CAAC,OAAU,OAAM,IAAI,MAAM;AAC/B,QAAO,CAAC;EAAE,OAAO;EAAU,KAAK;;;;;;AAMlC,SAAgB,0BACd,UACA,SACQ;AACR,QAAO,KAAK,sBAAsB,mBAAmB,WAAW,QAAW;;;;;AAM7E,SAAgB,uBACd,UACA,QACA,UACA,SACA,QACA,aACA,SACsB;CACtB,MAAM,kBAAkB,mBAAmB;CAM3C,MAAM,oBAAoB,IAAI,QAC3B,OAAO,QAAQ,UACf,KAAK,UAA2B;EAC/B,IAAM,KAAK,sBAAsB,KAAK,WAAW,KAAK,eAAe;EACrE,MAAM,CACJ,KAAK,aAAiB,iBACtB,KAAK,iBAAiB,SAAS;;CAIrC,MAAM,uBAAuB,IAAI,QAC9B,OAAO,EAAE,WAAW,mBAAmB,SAAS,QAAQ,aACxD,KAAK,UAA2B;EAC/B,IAAM,KAAK,sBAAsB,KAAK,WAAW,QAAW;EAC5D,MAAM,CACJ,KAAK,aAAa,iBAClB;;AAIN,QAAO,cAAc,mBAClB,OACC,MAAK,EAAE,OAAO,wBACd,MAAK,OAAO,IAAG,QAAKA,IAAE,MACtB,MAAK,EACF,KAAK,EAAE,IAAI,MAAM,CAAC,YAAY,oBAAoB;EAEjD,MAAM,QAAQ,uBAAuB,YAAY,cAAc;AAC/D,MAAI,CAAC,MAAO;AACZ,SAAO;GAAE;GAAI;;IAEd,QAAO,QAAKA,OAAK,OAErB"}

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

@@ -0,0 +1,44 @@
+import { getIdKey, getVertexId } from "../../../core/util.js";
+import { makeChainable } from "../../../common/make-chainable/index.js";
+import { anyRangesOverlap } from "../../../common/functions.js";
+import { groupBy } from "lodash-es";
+import moment from "moment";
+
+//#region src/RS/to/input/periods.ts
+function createRange({ start, end }) {
+	return {
+		start: moment.utc(start).clone().startOf("isoWeek").startOf("day"),
+		end: moment.utc(end).clone().endOf("isoWeek").endOf("day")
+	};
+}
+function parsePeriods(periods, division, options) {
+	const idKey = getIdKey(options);
+	if (!periods?.length) return { map: /* @__PURE__ */ new Map() };
+	const parsedPeriods = periods.map((x) => ({
+		id: getVertexId(x, idKey),
+		ranges: x.ranges.map((r) => createRange(r))
+	}));
+	parsedPeriods.push({
+		id: void 0,
+		ranges: [createRange(division)]
+	});
+	const grouped = makeChainable(parsedPeriods).chain((x) => x.map((x$1) => ({
+		...x$1,
+		overlap: parsedPeriods.map((y) => anyRangesOverlap(x$1.ranges, y.ranges) ? "1" : "0").join("")
+	})), (x) => groupBy(x, (x$1) => x$1.overlap), (x) => Object.values(x).map((x$1, i) => ({
+		ids: x$1.map((x$2) => x$2.id),
+		index: i,
+		ranges: x$1[0].ranges
+	}))).value;
+	const matrix = grouped.map((x) => grouped.map((y) => anyRangesOverlap(x.ranges, y.ranges) ? "1" : "0").join("")).join("");
+	if (matrix == "" || matrix == "0") throw new Error("(RS::V3::To::parsePeriods) invalid matrix value: " + matrix);
+	const indexMap = new Map(grouped.flatMap((xs) => xs.ids.map((id) => [id, xs.index])));
+	return {
+		map: indexMap,
+		matrix
+	};
+}
+
+//#endregion
+export { parsePeriods };
+//# sourceMappingURL=periods.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"periods.js","names":["x"],"sources":["../../../../src/RS/to/input/periods.ts"],"sourcesContent":["import { groupBy } from 'lodash-es';\nimport moment from 'moment';\nimport { getIdKey, getVertexId } from '../../../core/util';\nimport type { Interval } from '../../../core/types/common/intervals';\nimport type { ConnectedTypes } from '../../make-connected';\nimport type { Types } from '../../types';\nimport { anyRangesOverlap } from '../../../common/functions';\nimport { makeChainable } from '../../../common/make-chainable';\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()\n      .startOf('isoWeek')\n      .startOf('day'),\n    end: moment.utc(end).clone()\n      .endOf  ('isoWeek')\n      .endOf  ('day')\n  };\n}\n\ntype Out = {\n  map:     Map<string | undefined, number>,\n  matrix?: string\n};\n\nexport function parsePeriods (\n  periods:  ConnectedTypes.period[] | undefined,\n  division: ConnectedTypes.division,\n  options:  Types.parsedToOptions\n): Out {\n  const idKey = getIdKey(options);\n\n  // if empty periods are given, return empty map only\n  if (!periods?.length) {\n    return { map: new Map<string | undefined, number>() };\n  }\n\n  // convert the ranges to moment ranges\n  const parsedPeriods = periods.map(x => ({ id: getVertexId(x, idKey) as string | undefined, ranges: x.ranges.map(r => createRange(r)) }));\n\n  // add default period that includes all weeks\n  parsedPeriods.push({ id: undefined, ranges: [createRange(division)] });\n\n  // Compute a pairwise binary overlapping string for each periods and group those that have identical such string.\n  // The latter so that the number of periods may be reduced by omitting periods that overlap identically\n  const grouped = makeChainable(parsedPeriods)\n    .chain(\n      x => x\n        .map(x => ({\n          ...x,\n          overlap: parsedPeriods.map(y => anyRangesOverlap(x.ranges, y.ranges) ? '1' : '0').join('')\n        })),\n      x => groupBy(x, x => x.overlap),\n      x => Object.values(x)\n        .map((x, i) => ({ ids: x.map(x => x.id), index: i,  ranges: x[0].ranges }))\n    )\n    .value;\n\n  // Merge the pairwise binary overlapping string and store it as a matrix string.\n  const matrix = grouped\n    .map(x => grouped\n      .map(y => anyRangesOverlap(x.ranges, y.ranges) ? '1' : '0')\n      .join('')\n    )\n    .join('');\n\n  if (matrix == '' || matrix == '0') {\n    throw new Error('(RS::V3::To::parsePeriods) invalid matrix value: ' + matrix);\n  }\n\n  // Also store in a map what period id corresponds to which row in the matrix.\n  const indexMap = new Map(\n    grouped.flatMap(xs => xs.ids.map(id => ([id, xs.index]) as const))\n  );\n\n  return { map: indexMap, matrix };\n}\n\n"],"mappings":";;;;;;;AAYA,SAAS,YAAa,EAAE,OAAO,OAAyB;AACtD,QAAO;EACL,OAAO,OAAO,IAAI,OAAO,QACtB,QAAQ,WACR,QAAQ;EACX,KAAK,OAAO,IAAI,KAAK,QAClB,MAAQ,WACR,MAAQ;;;AASf,SAAgB,aACd,SACA,UACA,SACK;CACL,MAAM,QAAQ,SAAS;AAGvB,KAAI,CAAC,SAAS,OACZ,QAAO,EAAE,qBAAK,IAAI;CAIpB,MAAM,gBAAgB,QAAQ,KAAI,OAAM;EAAE,IAAI,YAAY,GAAG;EAA8B,QAAQ,EAAE,OAAO,KAAI,MAAK,YAAY;;AAGjI,eAAc,KAAK;EAAE,IAAI;EAAW,QAAQ,CAAC,YAAY;;CAIzD,MAAM,UAAU,cAAc,eAC3B,OACC,MAAK,EACF,KAAI,SAAM;EACT,GAAGA;EACH,SAAS,cAAc,KAAI,MAAK,iBAAiBA,IAAE,QAAQ,EAAE,UAAU,MAAM,KAAK,KAAK;OAE3F,MAAK,QAAQ,IAAG,QAAKA,IAAE,WACvB,MAAK,OAAO,OAAO,GAChB,KAAK,KAAG,OAAO;EAAE,KAAKA,IAAE,KAAI,QAAKA,IAAE;EAAK,OAAO;EAAI,QAAQA,IAAE,GAAG;MAEpE;CAGH,MAAM,SAAS,QACZ,KAAI,MAAK,QACP,KAAI,MAAK,iBAAiB,EAAE,QAAQ,EAAE,UAAU,MAAM,KACtD,KAAK,KAEP,KAAK;AAER,KAAI,UAAU,MAAM,UAAU,IAC5B,OAAM,IAAI,MAAM,sDAAsD;CAIxE,MAAM,WAAW,IAAI,IACnB,QAAQ,SAAQ,OAAM,GAAG,IAAI,KAAI,OAAO,CAAC,IAAI,GAAG;AAGlD,QAAO;EAAE,KAAK;EAAU"}