@royalschedule/maps 4.0.33 → 4.1.1-beta.0

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

@@ -1 +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 { idOf } from './util/util';\nimport { makeChainable } from '../../../common/make-chainable';\nimport type { GroupWithExclude } from '../../../core/interfaces/vertices/util/edges';\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.includeEntityMeta) {\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: GroupWithExclude.Util.Value<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.includeEntityMeta) {\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): GroupWithExclude.Util.Value<ConnectedTypes.group, ConnectedTypes.person>[] | undefined => {\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.toModel == 'groups');\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,QAAQ;GACnC,OAAO,OAAO,QAAQ,UAAW,YAAY,OAAO,OAAO,QAAQ,KAAM;GAC1E;AAED,MAAI,QAAQ,kBACV,KAAI,OAAO,OAAO;GAChB,KAAM,OAAO;GACb,MAAM,OAAO;GACd,GAAE,MAAK,KAAK,KAAK;AAGpB,SAAO,OAAO,MAAK,MAAK,KAAK,KAAK;GAClC;;AAGJ,SAAS,0BACP,IACA,WACA,SACsB;CACtB,MAAM,UAAY,IAAI,IAAI,UAAU,GAAG,SAAS,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC,CAAC;CAClF,MAAM,WAAY,IAAI,IAAI,UAAU,SAAS,KAAI,MAAK,YAAY,GAAG,QAAQ,CAAC,CAAC;CAG/E,MAAMC,MAA4B;EACnB;EACb,aAAa,CAAC,GAJE,QAAQ,WAAW,SAAS,CAIjB,CAAC,KAAI,MAAK,KAAK,OAAO,GAAG,QAAQ,CAAC;EAC9D;AAED,KAAI,QAAQ,kBACV,KAAI,OAAO,OAAO,EAChB,MAAM,UAAU,GAAG,eAAe,UAAU,SAAS,SAAS,WAAY,UAAU,QAAQ,KAAI,MAAK,EAAE,YAAY,CAAC,KAAK,KAAK,CAAE,KAAK,KACtI,GAAE,MAAK,KAAK,KAAK;AAGpB,QAAO;;AAwBT,SAAgB,yBACd,SACA,SACA,QACA,aACA,SAC6C;CAC7C,MAAM,cAAc,yBAAyB,SAAS,QAAQ;CAE9D,MAAM,2CAA2C,cAAc;EAAC,GAAG;EAAS,GAAG;EAAQ,GAAG;EAAY,CAAC,CACpG,OACC,MAAK,EACF,KAAK,SAAiG;AACrG,MAAI,YAAe,KAAM,QAAO,KAAK;AACrC,MAAI,eAAe,KAAM,QAAO,KAAK,WACjC,QAAO,QAAKC,IAAE,WAAW,SAAS;GAEtC,CACD,SAAQ,gBAAe,cAAc,EAAE,EACrC,QAAO,QAAKA,IAAE,GAAG,WAAW,WAAWA,IAAE,SAAS,OAAO,CACzD,KAAI,SAAM;EAAE,IAAI,KAAK,eAAeA,KAAG,QAAQ;EAAE,OAAOA;EAAG,EAAE,CAC/D,GACH,MAAK,OAAO,IAAG,QAAKA,IAAE,GAAG,CACtB,KAAI,QAAK,0BAA0BA,IAAE,IAAIA,IAAE,OAAO,QAAQ,CAAC,CAC/D,CACA;AAiBH,QAAO,YACJ,OAAO,yCAAyC"}
+{"version":3,"file":"individuals.js","names":["doc: Types.Entities.Individual","doc: Types.Entities.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 { idOf } from './util/util';\nimport { makeChainable } from '../../../common/make-chainable';\nimport type { GroupWithExclude } from '../../../core/interfaces/vertices/util/edges';\n\n\nfunction fromPersonsToIndividuals (\n  persons:  ConnectedTypes.person[],\n  options:  Types.parsedToOptions\n): Types.Entities.Individual[] {\n  return persons.map(person => {\n    const doc: Types.Entities.Individual = {\n      id:    idOf.person(person, options),\n      group: person.group ? `groups.${ getVertexId(person.group, options) }` : undefined,\n    };\n\n    if (options.includeEntityMeta) {\n      doc.name = person.displayName;\n    }\n\n    return omitBy(doc, x => x == null) as Types.Entities.Individual;\n  });\n}\n\nfunction fromGroupToIndividualsSet (\n  id:        string,\n  reference: GroupWithExclude.Util.Value<ConnectedTypes.group, ConnectedTypes.person>,\n  options:   Types.parsedToOptions\n): Types.Entities.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.Entities.IndividualsSet = {\n    id:          id,\n    individuals: [...remaining].map(x => idOf.person(x, options)),\n  };\n\n  if (options.includeEntityMeta) {\n    doc.name = reference.to.displayName + (reference.exclude?.length ? ` (excl. ${ reference.exclude.map(x => x.displayName).join(', ') })` : '');\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.Entities.Individual | Types.Entities.IndividualsSet)[] {\n  const individuals = fromPersonsToIndividuals(persons, options);\n\n  const uniqueIndividualsSetsFromGroupReferences = makeChainable([...courses, ...events, ...lockedTimes])\n    .chain(\n      x => x\n        .map((item): GroupWithExclude.Util.Value<ConnectedTypes.group, ConnectedTypes.person>[] | undefined => {\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.toModel == 'groups');\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  return individuals.concat(uniqueIndividualsSetsFromGroupReferences);\n};\n"],"mappings":";;;;;;AASA,SAAS,yBACP,SACA,SAC6B;AAC7B,QAAO,QAAQ,KAAI,WAAU;EAC3B,MAAMA,MAAiC;GACrC,IAAO,KAAK,OAAO,QAAQ;GAC3B,OAAO,OAAO,QAAQ,UAAW,YAAY,OAAO,OAAO,aAAc;;AAG3E,MAAI,QAAQ,kBACV,KAAI,OAAO,OAAO;AAGpB,SAAO,OAAO,MAAK,MAAK,KAAK;;;AAIjC,SAAS,0BACP,IACA,WACA,SAC+B;CAC/B,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,MAAqC;EAC5B;EACb,aAAa,CAAC,GAAG,WAAW,KAAI,MAAK,KAAK,OAAO,GAAG;;AAGtD,KAAI,QAAQ,kBACV,KAAI,OAAO,UAAU,GAAG,eAAe,UAAU,SAAS,SAAS,WAAY,UAAU,QAAQ,KAAI,MAAK,EAAE,aAAa,KAAK,MAAO,KAAK;AAG5I,QAAO;;AAGT,SAAgB,yBACd,SACA,SACA,QACA,aACA,SAC+D;CAC/D,MAAM,cAAc,yBAAyB,SAAS;CAEtD,MAAM,2CAA2C,cAAc;EAAC,GAAG;EAAS,GAAG;EAAQ,GAAG;IACvF,OACC,MAAK,EACF,KAAK,SAAiG;AACrG,MAAI,YAAe,KAAM,QAAO,KAAK;AACrC,MAAI,eAAe,KAAM,QAAO,KAAK,WACjC,QAAO,QAAKC,IAAE,WAAW;IAG9B,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;AAEH,QAAO,YAAY,OAAO"}

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

@@ -1,13 +1,14 @@
 import { fromLocations } from "./dependencies.js";
 import { extractUniqueIntervals } from "./intervals.js";
 import { fromTeachers } from "./teachers.js";
-import { fromCollections } from "./collections.js";
+import { fromEvents } from "./events.js";
 import { parseSettings } from "./settings.js";
-import { _parsePeriods, parsePeriods } from "./periods.js";
 import { parseDefault } from "./default.js";
-import { fromDynamicLockedTimes } from "./dynamic-locked-times.js";
+import { fromLockedTimes } from "./locked-times.js";
+import { parsePeriods } from "./periods.js";
 import { fromGroups } from "./groups.js";
 import { extractUniqueIndividuals } from "./individuals.js";
+import { fromLinkedEventsSets } from "./linked-events-sets.js";
 
 //#region src/RS/to/input/input.ts
 function parseInput(data, options = {}) {
@@ -21,6 +22,7 @@ function parseInput(data, options = {}) {
 	const _courses = data.courses ?? [];
 	const _persons = data.persons ?? [];
 	const _periods = data.periods ?? [];
+	const _linkedEventsSets = data.linkedEventsSets ?? [];
 	[
 		_groups,
 		_teachers,
@@ -33,19 +35,25 @@ function parseInput(data, options = {}) {
 			else if (entity.intervals === null) entity.intervals = void 0;
 		});
 	});
-	const { map: periodsMap, matrix: periodsMatrix } = parsePeriods(_periods, _division, options);
-	const periods = periodsMatrix?.length ? periodsMatrix : void 0;
-	return {
+	const _fromEvents = fromEvents(_events, _settings, options);
+	const _fromLockedTimes = fromLockedTimes(_lockedTimes, _settings, options);
+	const presentEventIds = new Set(_fromEvents.events.map((x) => x.id));
+	const linkedEvents = fromLinkedEventsSets(_linkedEventsSets, _settings, presentEventIds, options);
+	const out = {
 		settings: parseSettings(_settings),
-		default: parseDefault(_settings, periodsMap, options),
-		periods,
-		_periods: _parsePeriods(_periods, _division, options),
-		intervals: options.oldFormat ? void 0 : extractUniqueIntervals(_settings, _groups, _teachers, _courses, _events, _lockedTimes, options),
+		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).concat(fromTeachers(_teachers, _settings, options)),
-		individuals: options.oldFormat ? void 0 : extractUniqueIndividuals(_persons, _courses, _events, _lockedTimes, options),
-		events: [...fromCollections(_courses, _settings, options, periodsMap), ...fromDynamicLockedTimes(_lockedTimes, _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: []
 	};
+	return out;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"input.js","names":[],"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, _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  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\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\n  const { map: periodsMap, matrix: periodsMatrix } = parsePeriods(_periods, _division, options);\n  const periods = periodsMatrix?.length ? periodsMatrix : undefined;  // cannot be an empty string\n\n  const out: Types.scheduleData = {\n    settings: parseSettings(_settings),\n    default:  parseDefault (_settings, periodsMap, options),\n\n    periods:  periods,\n    _periods: _parsePeriods(_periods, _division, options),\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: [\n      ...fromCollections(_courses, _settings, options, periodsMap),\n      ...fromDynamicLockedTimes(_lockedTimes, _settings, options)\n    ]\n  };\n  return out;\n};"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,WACd,MACA,UAAiC,EAAE,EACf;CAEpB,MAAM,YAAe,KAAK;CAC1B,MAAM,YAAe,KAAK;CAC1B,MAAM,UAAe,KAAK,UAAe,EAAE;CAC3C,MAAM,YAAe,KAAK,YAAe,EAAE;CAC3C,MAAM,aAAe,KAAK,aAAe,EAAE;CAC3C,MAAM,UAAe,KAAK,UAAe,EAAE;CAC3C,MAAM,eAAe,KAAK,eAAe,EAAE;CAC3C,MAAM,WAAe,KAAK,WAAe,EAAE;CAC3C,MAAM,WAAe,KAAK,WAAe,EAAE;CAC3C,MAAM,WAAe,KAAK,WAAe,EAAE;AAM3C;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;CAGF,MAAM,EAAE,KAAK,YAAY,QAAQ,kBAAkB,aAAa,UAAU,WAAW,QAAQ;CAC7F,MAAM,UAAU,eAAe,SAAS,gBAAgB;AAuBxD,QArBgC;EAC9B,UAAU,cAAc,UAAU;EAClC,SAAU,aAAc,WAAW,YAAY,QAAQ;EAE7C;EACV,UAAU,cAAc,UAAU,WAAW,QAAQ;EAErD,WAAW,QAAQ,YAAY,SAAY,uBAAuB,WAAW,SAAS,WAAW,UAAU,SAAS,cAAc,QAAQ;EAE1I,cAAc,cAAc,YAAY,WAAW,QAAQ;EAE3D,QAAQ,WAAW,SAAS,WAAW,QAAQ,CAC5C,OAAO,aAAa,WAAW,WAAW,QAAQ,CAAC;EAEtD,aAAa,QAAQ,YAAY,SAAY,yBAAyB,UAAU,UAAU,SAAS,cAAc,QAAQ;EAEzH,QAAQ,CACN,GAAG,gBAAgB,UAAU,WAAW,SAAS,WAAW,EAC5D,GAAG,uBAAuB,cAAc,WAAW,QAAQ,CAC5D;EACF"}
+{"version":3,"file":"input.js","names":["out: Types.scheduleData"],"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,IACb;CAEpB,MAAM,YAAoB,KAAK;CAC/B,MAAM,YAAoB,KAAK;CAC/B,MAAM,UAAoB,KAAK,UAAoB;CACnD,MAAM,YAAoB,KAAK,YAAoB;CACnD,MAAM,aAAoB,KAAK,aAAoB;CACnD,MAAM,UAAoB,KAAK,UAAoB;CACnD,MAAM,eAAoB,KAAK,eAAoB;CACnD,MAAM,WAAoB,KAAK,WAAoB;CACnD,MAAM,WAAoB,KAAK,WAAoB;CACnD,MAAM,WAAoB,KAAK,WAAoB;CACnD,MAAM,oBAAoB,KAAK,oBAAoB;AAMnD;EAAC;EAAS;EAA6B;EAAU;EAAS;GAAc,SAAQ,aAAY;AAC1F,WAAS,SAAQ,WAAU;AACzB,OAAS,OAAO,aAAa,OAAO,UAAU,UAAU,EAAG,QAAO,YAAY;YACrE,OAAO,cAAc,KAA6B,QAAO,YAAY;;;CAIlF,MAAM,cAAmB,WAAgB,SAAc,WAAW;CAClE,MAAM,mBAAmB,gBAAgB,cAAc,WAAW;CAElE,MAAM,kBAAkB,IAAI,IAAI,YAAY,OAAO,KAAI,MAAK,EAAE;CAE9D,MAAM,eAAe,qBAAqB,mBAAmB,WAAW,iBAAiB;CAEzF,MAAMA,MAA0B;EAC9B,UAAU,cAAc;EACxB,SAAU,aAAc,WAAW;EAEnC,SAAW,aAAa,UAAU,WAAW;EAC7C,WAAW,uBAAuB,WAAW,SAAS,WAAW,UAAU,SAAS,cAAc;EAElG,cAAc,cAAc,YAAY,WAAW;EAEnD,QAAQ,CACN,GAAG,WAAa,SAAS,WAAW,UACpC,GAAG,aAAa,WAAW,WAAW;EAGxC,aAAa,yBAAyB,UAAU,UAAU,SAAS,cAAc;EAEjF,cAAc,iBAAiB;EAE/B,QAAQ,CACN,GAAG,YAAY,QACf,GAAG,iBAAiB;EAGtB,YAAY,CACV,GAAG,YAAY,YACf,GAAG,iBAAiB;EAGR;EAEd,gBAAgB;;AAElB,QAAO"}

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

@@ -42,10 +42,12 @@ function standardizeIntervals(intervals, settings) {
 */
 function toFloatIntervals(intervals) {
 	return intervals?.map((i, day) => {
-		if (!i.start || !i.end) throw new Error(`(RS::To::convertIntervals) Interval missing start or end for day ${day}: ${JSON.stringify(i)}`);
+		if (!i.start || !i.end) throw new Error(`(RS::To::toFloatIntervals) Interval missing start or end for day ${day}: ${JSON.stringify(i)}`);
+		const start = parseFloat(parseIntervalDate(i.start).format("HH.mm"));
+		const end = parseFloat(parseIntervalDate(i.end).format("HH.mm"));
 		return {
-			beg: parseFloat(parseIntervalDate(i.start).format("HH.mm")),
-			end: parseFloat(parseIntervalDate(i.end).format("HH.mm"))
+			start,
+			end
 		};
 	});
 }
@@ -55,15 +57,15 @@ function toFloatIntervals(intervals) {
 function combineAndMapIntervals(_intervals, rootInterval, settings) {
 	const intervals = toFloatIntervals(standardizeIntervals(_intervals, settings));
 	if (rootInterval) {
-		if (!intervals) throw new Error("(RS::To::parseIntervals) no accompanying intervals for 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::Intervals) Day ${day} not found in dayStartAndEnds`);
+			if (!limits) throw new Error(`(RS::To::combineAndMapIntervals) Day ${day} not found in dayStartAndEnds`);
 			return is.map((i) => ({
-				beg: parseFloat(parseIntervalDate(i.start).format("HH.mm")),
+				start: parseFloat(parseIntervalDate(i.start).format("HH.mm")),
 				end: parseFloat(parseIntervalDate(i.end).format("HH.mm")),
 				binary: true
-			})).filter((i) => i.beg >= limits.beg && i.end <= limits.end);
+			})).filter((i) => i.start >= limits.start && i.end <= limits.end);
 		}).reduce((acc, curr, index) => {
 			acc[index] = curr;
 			return acc;
@@ -125,5 +127,5 @@ function extractUniqueIntervals(settings, groups, teachers, courses, events, loc
 }
 
 //#endregion
-export { computesDefaultIntervalId, extractUniqueIntervals, getDefaultInterval, parseIntervalDate };
+export { computesDefaultIntervalId, extractUniqueIntervals, getDefaultInterval };
 //# sourceMappingURL=intervals.js.map

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

@@ -1 +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 { 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): { beg: number, end: number }[] | undefined {\n  return intervals?.map((i, day: number) => {\n    if (!i.start || !i.end) throw new Error(`(RS::To::convertIntervals) 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 { beg: start, end: 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.interval[][] | undefined {\n  const intervals = toFloatIntervals(standardizeIntervals(_intervals, settings));\n\n  if (rootInterval) {\n    if (!intervals) throw new Error('(RS::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::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(parseIntervalDate(i.start).format('HH.mm')),\n                end:    parseFloat(parseIntervalDate(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          // ensure that all days are represented, even if empty\n          .reduce<Types.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.rootInterval[] {\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.rootInterval>;\n        })\n        .filter(x => x != null)\n    )\n    .value;\n};\n"],"mappings":"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"}
+{"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 { 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.js

@@ -0,0 +1,96 @@
+import { getVertexId } from "../../../core/util.js";
+import { idOf } from "./util/util.js";
+
+//#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$1) => presentEventIds.has(idOf.event(x$1, 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$1) => idOf.event(x$1, 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$1) => idOf.event(x$1, 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.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linked-events-sets.js","names":["x","configurations: Configurations","gaps: number[]","newConfigurations: Configurations"],"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":";;;;AAMA,SAAgB,qBACd,mBACA,WACA,iBACA,SACkC;AAElC,SAAQ,qBAAqB,IAC1B,KAAI,MAAK;AAER,MAAI,EAAE,SAAS,YAAY;AACzB,OAAI,EAAE,UAAU,KAAM,OAAM,IAAI,MAAM,qBAAqB,YAAY,GAAG,SAAS;AACnF,UAAO;IAAE,GAAG;IAAG,MAAM;IAAY,QAAQ,EAAE;;aAEpC,EAAE,SAAS,cAAc;AAChC,OAAI,EAAE,OAAO,KAAM,OAAM,IAAI,MAAM,qBAAqB,YAAY,GAAG,SAAS;AAChF,UAAO;IAAE,GAAG;IAAG,MAAM;IAAc,KAAK,EAAE;;aAEnC,EAAE,SAAS,SAClB,QAAO;GAAE,GAAG;GAAG,MAAM;;AAGvB,QAAM,IAAI,MAAM,qBAAqB,YAAY,GAAG,SAAS;IAE9D,KAAK,MAAsC;EAE1C,MAAM,KAAK,YAAY,GAAG;EAE1B,MAAM,mBAAmB,EAAE,OAAO,QAAO,QAAK,gBAAgB,IAAI,KAAK,MAAMA,KAAG;EAChF,MAAM,OAAO,EAAE;AACf,MAAI,SAAS,YAAY;GACvB,MAAMC,iBAAiC;GACvC,MAAM,SAAS,EAAE;AACjB,WAAQ,QAAR;IACE,KAAK;AAAU,oBAAe,KAAK,iBAAiB,WAAW;MAAE,QAAQ;MAAU,QAAQ;;AAAQ;IACnG,KAAK;AAAU,oBAAe,KAAK,iBAAiB,WAAW;MAAE,QAAQ;MAAU,QAAQ;;AAAQ;IACnG,KAAK;AAAU,oBAAe,KAAK,iBAAiB,WAAW;MAAE,QAAQ;MAAU,QAAQ;;AAAQ;IACnG,QAAS,OAAM,IAAI,MAAM,wBAAwB,OAAiC,yBAAyB,YAAY,GAAG;;AAE5H,UAAO;IACL;IAAI;IACJ,QAAQ,iBAAiB,KAAI,QAAK,KAAK,MAAMD,KAAG;;;AAIpD,MAAI,SAAS,cAAc;GACzB,MAAM,EAAE,KAAK,QAAQ,EAAE;GACvB,MAAM,KAAK,UAAU;GAErB,MAAM,oBAAoB,KAAK,IAAI,IAAI,KAAK,MAAM,MAAI,KAAK,MAAI,KAAK,iBAAiB,SAAS;GAC9F,MAAM,uBAAuB;AAC7B,OAAI,qBAAqB,qBAAsB,OAAM,IAAI,MAAM,qBAAqB,YAAY,GAAG,SAAS,gCAAgC,kBAAkB,mBAAmB,qBAAqB;GAEtM,MAAME,OAAiB;AACvB,QAAK,IAAI,IAAI,KAAK,KAAK,KAAK,KAAK,GAAI,MAAK,KAAK;GAE/C,IAAID,iBAAiC,CAAC,CAAC;IAAE,QAAQ;IAAS,QAAQ;;AAClE,QAAK,IAAI,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;IAChD,MAAME,oBAAoC;AAC1C,SAAK,MAAM,UAAU,gBAAgB;KACnC,MAAM,mBAAmB,OAAO,OAAO,SAAS,GAAG,SAAS,iBAAiB,IAAI,GAAG;AACpF,UAAK,MAAM,OAAO,KAChB,mBAAkB,KAAK,CAAC,GAAG,QAAQ;MAAE,QAAQ;MAAS,QAAQ,mBAAmB;;;AAGrF,qBAAiB;;AAGnB,UAAO;IACL;IAAI;IACJ,QAAQ,iBAAiB,KAAI,QAAK,KAAK,MAAMH,KAAG;;;AAIpD,MAAI,SAAS,SACX,OAAM,IAAI,MAAM,sEAAsE,YAAY,GAAG,SAAS;AAGhH,QAAM,IAAI,MAAM,wCAAwC,KAA+B,yBAAyB,YAAY,GAAG;IAEhI,QAAO,MAAK,EAAE,OAAO,SAAS"}

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

@@ -0,0 +1,91 @@
+import { getDayIndex, getVertexId, parseDateInterval } from "../../../core/util.js";
+import { makeChainable } from "../../../common/make-chainable/index.js";
+import { idOf } from "./util/util.js";
+import { getDefaultInterval } from "./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/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 = 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 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);
+	const events = [...complementaryHours, ...lunches];
+	const activities = Object.entries(groupBy(complementaryHours, (x) => [x.distributionKey].flat().toSorted().join("|"))).map(([id, events$1]) => ({
+		id: `COMPLEMENTARY_TIME.${id}`,
+		events: events$1.map((x) => x.id)
+	}));
+	return {
+		events,
+		activities,
+		blockedTimes
+	};
+}
+
+//#endregion
+export { fromLockedTimes };
+//# sourceMappingURL=locked-times.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locked-times.js","names":["doc: Types.Entities.BlockedTime","x","doc: Types.Entities.Event","events"],"sources":["../../../../src/RS/to/input/locked-times.ts"],"sourcesContent":["import { groupBy, omitBy, uniq } from 'lodash-es';\nimport type { ConnectedTypes } from '../../make-connected';\nimport { getDayIndex, getVertexId, 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';\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  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 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.js

@@ -1,7 +1,5 @@
-import { getIdKey, getVertexId } from "../../../core/util.js";
-import { makeChainable } from "../../../common/make-chainable/index.js";
 import { range } from "../../../common/functions.js";
-import { groupBy } from "lodash-es";
+import { getVertexId } from "../../../core/util.js";
 import moment from "moment";
 
 //#region src/RS/to/input/periods.ts
@@ -11,41 +9,11 @@ function createRange({ start, end }) {
 		end: moment.utc(end).clone().endOf("isoWeek")
 	};
 }
-/**
-* Used by the default values as the id if no period is specified.
-*/
-const DEFAULT_PERIOD_ID = "DEFAULT_PERIOD";
 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: DEFAULT_PERIOD_ID,
-		ranges: [createRange(division)]
-	});
-	const grouped = makeChainable(parsedPeriods).chain((x) => x.map((x$1) => ({
-		...x$1,
-		overlap: parsedPeriods.map((y) => range.overlaps(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) => range.overlaps(x.ranges, y.ranges) ? "1" : "0").join("")).join("");
-	if (matrix == "" || matrix == "0") throw new Error("(RS::To::parsePeriods) invalid matrix value: " + matrix);
-	return {
-		map: new Map(grouped.flatMap((xs) => xs.ids.map((id) => [id, xs.index]))),
-		matrix
-	};
-}
-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 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(),
@@ -59,10 +27,11 @@ function _parsePeriods(periods, division, options) {
 			}
 		});
 		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("");
+		const overlaps = weeks.length <= 64 ? weeks : "";
 		return {
 			id,
 			weeks,
-			overlaps: weeks.length <= 64 ? weeks : ""
+			overlaps
 		};
 	});
 	if (weeksMap.size > 64 && out && out.length <= 64) for (let i = 0; i < out.length; i++) {
@@ -85,5 +54,5 @@ function _parsePeriods(periods, division, options) {
 }
 
 //#endregion
-export { DEFAULT_PERIOD_ID, _parsePeriods, parsePeriods };
+export { parsePeriods };
 //# sourceMappingURL=periods.js.map

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

@@ -1 +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 { ConnectedTypes } from '../../make-connected';\nimport type { Types } from '../../types';\nimport { range } from '../../../common/functions';\nimport { makeChainable } from '../../../common/make-chainable';\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\ntype Out = {\n  map:     Map<string | undefined, number>,\n  matrix?: string\n};\n\n/**\n * Used by the default values as the id if no period is specified.\n */\nexport const DEFAULT_PERIOD_ID = 'DEFAULT_PERIOD';\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: DEFAULT_PERIOD_ID, 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 => range.overlaps(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 => range.overlaps(x.ranges, y.ranges) ? '1' : '0')\n      .join('')\n    )\n    .join('');\n\n  if (matrix == '' || matrix == '0') {\n    throw new Error('(RS::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\nexport function _parsePeriods (\n  periods:  ConnectedTypes.period[] | undefined,\n  division: ConnectedTypes.division,\n  options:  Types.parsedToOptions\n): Types.period[] | undefined {\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.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":"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"}
+{"version":3,"file":"periods.js","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,OAAO,QAAQ,QAAQ;EACzC,KAAO,OAAO,IAAI,KAAO,QAAQ,MAAQ;;;AAI7C,SAAgB,aACd,SACA,UACA,SACyB;CACzB,MAAM,gBAAgB,YAAY;CAGlC,MAAM,2BAAW,IAAI;AACrB,MAAK,MAAM,IAAI,cAAc,MAAM,SAAS,EAAE,eAAe,cAAc,MAAM,EAAE,IAAI,GAAG,QACxF,UAAS,IAAI,EAAE,eAAe;CAGhC,MAAM,MAAM,QAAQ,KAAK,MAA6B;EACpD,MAAM,KAAK,YAAY,GAAG;EAG1B,MAAM,gBAAgB,EAAE,OACrB,KAAI,MAAK,YAAY,IACrB,QAAO,MAAK,MAAM,SAAS,GAAG,gBAC9B,KAAI,OAAM;GACT,OAAO,OAAO,IAAI,EAAE,OAAO,cAAc,OAAO;GAChD,KAAO,OAAO,IAAI,EAAE,KAAO,cAAc,KAAO;;EAIpD,MAAM,iBAAiB,IAAI,IAAI;AAC/B,gBAAc,SAAQ,MAAK;AACzB,QAAK,MAAM,IAAI,EAAE,MAAM,SAAS,EAAE,eAAe,EAAE,MAAM,EAAE,IAAI,GAAG,SAAS;IACzE,MAAM,MAAM,EAAE;AACd,mBAAe,IAAI,KAAK;;;EAK5B,MAAM,QAAQ,MAAM,KAAK,eAAe,WACrC,MAAM,GAAG,MAAM,OAAO,IAAI,EAAE,IAAI,KAAK,OAAO,IAAI,EAAE,MAClD,KAAI,MAAK,EAAE,KAAK,MAAM,KACtB,KAAK;EAER,MAAM,WAAW,MAAM,UAAU,KAAK,QAAQ;AAE9C,SAAO;GAAE;GAAI;GAAO;;;AAItB,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.js

@@ -4,14 +4,7 @@ function parseSettings(settings) {
 	if (!settings.discretization) throw new Error("(RS::To::parseSettings) discretization is falsy");
 	return {
 		numDays: settings.numDays,
-		discretization: settings.discretization,
-		periodIdKey: "id",
-		intervalIdKey: "id",
-		dependencyIdKey: "id",
-		groupIdKey: "id",
-		individualIdKey: "id",
-		collectionIdKey: "id",
-		eventIdKey: "id"
+		discretization: settings.discretization
 	};
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"settings.js","names":[],"sources":["../../../../src/RS/to/input/settings.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\n\nexport function parseSettings (settings: ConnectedTypes.divisionSettings): Types.settings {\n\n  if (!settings.numDays)        throw new Error('(RS::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    periodIdKey:     'id',\n    intervalIdKey:   'id',\n    dependencyIdKey: 'id',\n    groupIdKey:      'id',\n    individualIdKey: 'id',\n    collectionIdKey: 'id',\n    eventIdKey:      'id',\n  };\n};"],"mappings":";AAGA,SAAgB,cAAe,UAA2D;AAExF,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;EAEzB,aAAiB;EACjB,eAAiB;EACjB,iBAAiB;EACjB,YAAiB;EACjB,iBAAiB;EACjB,iBAAiB;EACjB,YAAiB;EAClB"}
+{"version":3,"file":"settings.js","names":[],"sources":["../../../../src/RS/to/input/settings.ts"],"sourcesContent":["import type { Types } from '../../types';\nimport type { ConnectedTypes } from '../../make-connected';\n\nexport function parseSettings (settings: ConnectedTypes.divisionSettings): Types.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;AAC9C,KAAI,CAAC,SAAS,eAAgB,OAAM,IAAI,MAAM;AAE9C,QAAO;EACL,SAAgB,SAAS;EACzB,gBAAgB,SAAS"}

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

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