@royalschedule/maps 4.1.0-beta.0 → 4.1.2-beta.0

package/dist/core/to/persons.js

@@ -0,0 +1,18 @@
+import { getVertexId } from "../util.js";
+import { omitEdgesAndInternalProperties } from "./util.js";
+
+//#region src/core/to/persons.ts
+var persons_default = (persons, options) => {
+	return persons.map((x) => {
+		const edges = { group: x.group ? getVertexId(x.group, options) : void 0 };
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
+		return {
+			...nonEdges,
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { persons_default as default };
+//# sourceMappingURL=persons.js.map

package/dist/core/to/persons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persons.js","names":["edges: SerializedEdgesOnlyVertexExport<PersonVertex>"],"sources":["../../../src/core/to/persons.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { PersonVertex } from '../interfaces/vertices/persons';\n\nexport default (\n  persons: Types.Mixed.Person[],\n  options: BaseOptions\n): OutTypes.person[] => {\n  return persons\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<PersonVertex> = {\n        group: x.group ? getVertexId(x.group, options) : undefined,\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<PersonVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,uBACE,SACA,YACsB;AACtB,QAAO,QACJ,KAAI,MAAK;EACR,MAAMA,QAAuD,EAC3D,OAAO,EAAE,QAAQ,YAAY,EAAE,OAAO,WAAW;EAEnD,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/root-intervals.js

@@ -0,0 +1,17 @@
+import { omitEdgesAndInternalProperties } from "./util.js";
+
+//#region src/core/to/root-intervals.ts
+var root_intervals_default = (rootIntervals, options) => {
+	return rootIntervals.map((x) => {
+		const edges = {};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
+		return {
+			...nonEdges,
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { root_intervals_default as default };
+//# sourceMappingURL=root-intervals.js.map

package/dist/core/to/root-intervals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-intervals.js","names":["edges: SerializedEdgesOnlyVertexExport<RootIntervalVertex>"],"sources":["../../../src/core/to/root-intervals.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { RootIntervalVertex } from '../interfaces/vertices/root-intervals';\n\nexport default (\n  rootIntervals: Types.Mixed.RootInterval[],\n  options:       BaseOptions\n): OutTypes.rootInterval[] => {\n  return rootIntervals\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<RootIntervalVertex> = {\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<RootIntervalVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;AAMA,8BACE,eACA,YAC4B;AAC5B,QAAO,cACJ,KAAI,MAAK;EACR,MAAMA,QAA6D;EAEnE,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

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

@@ -0,0 +1,48 @@
+import { InternalIdKey } from "../types/common/index.js";
+import { InternalKeysOmitted } from "./util.js";
+import { Types } from "../types/index.js";
+
+//#region src/core/to/schedules.d.ts
+declare namespace OutTypes {
+  type division = Omit<InternalKeysOmitted<Types.Serialized.Division>, InternalIdKey>;
+  type settings = InternalKeysOmitted<Types.Serialized.Settings>;
+  type configuration = InternalKeysOmitted<Types.Serialized.Configuration>;
+  type exception = InternalKeysOmitted<Types.Serialized.Exception>;
+  type period = InternalKeysOmitted<Types.Serialized.Period>;
+  type location = InternalKeysOmitted<Types.Serialized.Location>;
+  type teacher = InternalKeysOmitted<Types.Serialized.Teacher>;
+  type group = InternalKeysOmitted<Types.Serialized.Group>;
+  type person = InternalKeysOmitted<Types.Serialized.Person>;
+  type course = InternalKeysOmitted<Types.Serialized.Course>;
+  type event = InternalKeysOmitted<Types.Serialized.Event>;
+  type lockedTime = InternalKeysOmitted<Types.Serialized.LockedTime>;
+  type overlapGroup = InternalKeysOmitted<Types.Serialized.OverlapGroup>;
+  type rootInterval = InternalKeysOmitted<Types.Serialized.RootInterval>;
+  type syllabus = InternalKeysOmitted<Types.Serialized.Syllabus>;
+  type linkedEventsSet = InternalKeysOmitted<Types.Serialized.LinkedEventsSet>;
+}
+type Out = {
+  division?: OutTypes.division;
+  settings?: OutTypes.settings;
+  exceptions?: OutTypes.exception[];
+  periods?: OutTypes.period[];
+  locations?: OutTypes.location[];
+  teachers?: OutTypes.teacher[];
+  groups?: OutTypes.group[];
+  persons?: OutTypes.person[];
+  courses?: OutTypes.course[];
+  events?: OutTypes.event[];
+  lockedTimes?: OutTypes.lockedTime[];
+  overlapGroups?: OutTypes.overlapGroup[];
+  rootIntervals?: OutTypes.rootInterval[];
+  syllabuses?: OutTypes.syllabus[];
+  configurations?: OutTypes.configuration[];
+  linkedEventsSets?: OutTypes.linkedEventsSet[];
+  meta: {
+    structure: string;
+  };
+};
+declare function export_default(schedule: Partial<Types.Mixed.Schedule>): Out;
+//#endregion
+export { export_default };
+//# sourceMappingURL=schedules.d.ts.map

package/dist/core/to/schedules.js

@@ -0,0 +1,44 @@
+import exceptions_default from "./exceptions.js";
+import periods_default from "./periods.js";
+import locations_default from "./locations.js";
+import teachers_default from "./teachers.js";
+import groups_default from "./groups.js";
+import persons_default from "./persons.js";
+import courses_default from "./courses.js";
+import events_default from "./events.js";
+import locked_times_default from "./locked-times.js";
+import overlap_groups_default from "./overlap-groups.js";
+import root_intervals_default from "./root-intervals.js";
+import settings_default from "./settings.js";
+import division_default from "./division.js";
+import syllabuses_default from "./syllabuses.js";
+import configurations_default from "./configurations.js";
+import linked_events_sets_default from "./linked-events-sets.js";
+
+//#region src/core/to/schedules.ts
+function schedules_default(schedule) {
+	const options = {};
+	return {
+		meta: { structure: "RS/core-2.0.0" },
+		...schedule.divisions && { division: division_default(schedule.divisions, options) },
+		...schedule.settings && { settings: settings_default(schedule.settings, options) },
+		...schedule.exceptions && { exceptions: exceptions_default(schedule.exceptions, options) },
+		...schedule.periods && { periods: periods_default(schedule.periods, options) },
+		...schedule.locations && { locations: locations_default(schedule.locations, options) },
+		...schedule.teachers && { teachers: teachers_default(schedule.teachers, options) },
+		...schedule.groups && { groups: groups_default(schedule.groups, options) },
+		...schedule.persons && { persons: persons_default(schedule.persons, options) },
+		...schedule.courses && { courses: courses_default(schedule.courses, options) },
+		...schedule.events && { events: events_default(schedule.events, options) },
+		...schedule.lockedTimes && { lockedTimes: locked_times_default(schedule.lockedTimes, options) },
+		...schedule.overlapGroups && { overlapGroups: overlap_groups_default(schedule.overlapGroups, options) },
+		...schedule.rootIntervals && { rootIntervals: root_intervals_default(schedule.rootIntervals, options) },
+		...schedule.syllabuses && { syllabuses: syllabuses_default(schedule.syllabuses, options) },
+		...schedule.configurations && { configurations: configurations_default(schedule.configurations, options) },
+		...schedule.linkedEventsSets && { linkedEventsSets: linked_events_sets_default(schedule.linkedEventsSets, options) }
+	};
+}
+
+//#endregion
+export { schedules_default as default };
+//# sourceMappingURL=schedules.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedules.js","names":["options: BaseOptions","_division","_settings","_exceptions","_periods","_locations","_teachers","_groups","_persons","_courses","_events","_lockedTimes","_overlapGroups","_rootIntervals","_syllabuses","_configurations","_linkedEventsSets"],"sources":["../../../src/core/to/schedules.ts"],"sourcesContent":["import type { CoreTypes } from '../';\nimport _exceptions from './exceptions';\nimport _periods from './periods';\nimport _locations from './locations';\nimport _teachers from './teachers';\nimport _groups from './groups';\nimport _persons from './persons';\nimport _courses from './courses';\nimport _events from './events';\nimport _lockedTimes from './locked-times';\nimport _overlapGroups from './overlap-groups';\nimport _rootIntervals from './root-intervals';\nimport _settings from './settings';\nimport _division from './division';\nimport _syllabuses from './syllabuses';\nimport _configurations from './configurations';\nimport _linkedEventsSets from './linked-events-sets';\nimport type { InternalIdKey } from '../types/common';\nimport type { InternalKeysOmitted } from './util';\nimport type { BaseOptions } from '../../common/types';\n\nexport namespace OutTypes {\n  export type division        = Omit<InternalKeysOmitted<CoreTypes.Serialized.Division>, InternalIdKey>;\n  export type settings        = InternalKeysOmitted<CoreTypes.Serialized.Settings>;\n  export type configuration   = InternalKeysOmitted<CoreTypes.Serialized.Configuration>;\n  export type exception       = InternalKeysOmitted<CoreTypes.Serialized.Exception>;\n  export type period          = InternalKeysOmitted<CoreTypes.Serialized.Period>;\n  export type location        = InternalKeysOmitted<CoreTypes.Serialized.Location>;\n  export type teacher         = InternalKeysOmitted<CoreTypes.Serialized.Teacher>;\n  export type group           = InternalKeysOmitted<CoreTypes.Serialized.Group>;\n  export type person          = InternalKeysOmitted<CoreTypes.Serialized.Person>;\n  export type course          = InternalKeysOmitted<CoreTypes.Serialized.Course>;\n  export type event           = InternalKeysOmitted<CoreTypes.Serialized.Event>;\n  export type lockedTime      = InternalKeysOmitted<CoreTypes.Serialized.LockedTime>;\n  export type overlapGroup    = InternalKeysOmitted<CoreTypes.Serialized.OverlapGroup>;\n  export type rootInterval    = InternalKeysOmitted<CoreTypes.Serialized.RootInterval>;\n  export type syllabus        = InternalKeysOmitted<CoreTypes.Serialized.Syllabus>;\n  export type linkedEventsSet = InternalKeysOmitted<CoreTypes.Serialized.LinkedEventsSet>;\n}\n\ntype Out = {\n  division?:       OutTypes.division;\n  settings?:       OutTypes.settings;\n  exceptions?:     OutTypes.exception[];\n  periods?:        OutTypes.period[];\n  locations?:      OutTypes.location[];\n  teachers?:       OutTypes.teacher[];\n  groups?:         OutTypes.group[];\n  persons?:        OutTypes.person[];\n  courses?:        OutTypes.course[];\n  events?:         OutTypes.event[];\n  lockedTimes?:    OutTypes.lockedTime[];\n  overlapGroups?:  OutTypes.overlapGroup[];\n  rootIntervals?:  OutTypes.rootInterval[];\n  syllabuses?:     OutTypes.syllabus[];\n  configurations?: OutTypes.configuration[];\n  linkedEventsSets?: OutTypes.linkedEventsSet[];\n  meta: { structure: string };\n};\n\nexport default function (\n  schedule: Partial<CoreTypes.Mixed.Schedule>\n): Out {\n  const options: BaseOptions = {};\n\n  return {\n    meta: { structure: 'RS/core-2.0.0' },\n    ...schedule.divisions        && { division:         _division        (schedule.divisions,        options) },\n    ...schedule.settings         && { settings:         _settings        (schedule.settings,         options) },\n    ...schedule.exceptions       && { exceptions:       _exceptions      (schedule.exceptions,       options) },\n    ...schedule.periods          && { periods:          _periods         (schedule.periods,          options) },\n    ...schedule.locations        && { locations:        _locations       (schedule.locations,        options) },\n    ...schedule.teachers         && { teachers:         _teachers        (schedule.teachers,         options) },\n    ...schedule.groups           && { groups:           _groups          (schedule.groups,           options) },\n    ...schedule.persons          && { persons:          _persons         (schedule.persons,          options) },\n    ...schedule.courses          && { courses:          _courses         (schedule.courses,          options) },\n    ...schedule.events           && { events:           _events          (schedule.events,           options) },\n    ...schedule.lockedTimes      && { lockedTimes:      _lockedTimes     (schedule.lockedTimes,      options) },\n    ...schedule.overlapGroups    && { overlapGroups:    _overlapGroups   (schedule.overlapGroups,    options) },\n    ...schedule.rootIntervals    && { rootIntervals:    _rootIntervals   (schedule.rootIntervals,    options) },\n    ...schedule.syllabuses       && { syllabuses:       _syllabuses      (schedule.syllabuses,       options) },\n    ...schedule.configurations   && { configurations:   _configurations  (schedule.configurations,   options) },\n    ...schedule.linkedEventsSets && { linkedEventsSets: _linkedEventsSets(schedule.linkedEventsSets, options) },\n  };\n}"],"mappings":";;;;;;;;;;;;;;;;;;AA4DA,2BACE,UACK;CACL,MAAMA,UAAuB;AAE7B,QAAO;EACL,MAAM,EAAE,WAAW;EACnB,GAAG,SAAS,aAAoB,EAAE,UAAkBC,iBAAkB,SAAS,WAAkB;EACjG,GAAG,SAAS,YAAoB,EAAE,UAAkBC,iBAAkB,SAAS,UAAkB;EACjG,GAAG,SAAS,cAAoB,EAAE,YAAkBC,mBAAkB,SAAS,YAAkB;EACjG,GAAG,SAAS,WAAoB,EAAE,SAAkBC,gBAAkB,SAAS,SAAkB;EACjG,GAAG,SAAS,aAAoB,EAAE,WAAkBC,kBAAkB,SAAS,WAAkB;EACjG,GAAG,SAAS,YAAoB,EAAE,UAAkBC,iBAAkB,SAAS,UAAkB;EACjG,GAAG,SAAS,UAAoB,EAAE,QAAkBC,eAAkB,SAAS,QAAkB;EACjG,GAAG,SAAS,WAAoB,EAAE,SAAkBC,gBAAkB,SAAS,SAAkB;EACjG,GAAG,SAAS,WAAoB,EAAE,SAAkBC,gBAAkB,SAAS,SAAkB;EACjG,GAAG,SAAS,UAAoB,EAAE,QAAkBC,eAAkB,SAAS,QAAkB;EACjG,GAAG,SAAS,eAAoB,EAAE,aAAkBC,qBAAkB,SAAS,aAAkB;EACjG,GAAG,SAAS,iBAAoB,EAAE,eAAkBC,uBAAkB,SAAS,eAAkB;EACjG,GAAG,SAAS,iBAAoB,EAAE,eAAkBC,uBAAkB,SAAS,eAAkB;EACjG,GAAG,SAAS,cAAoB,EAAE,YAAkBC,mBAAkB,SAAS,YAAkB;EACjG,GAAG,SAAS,kBAAoB,EAAE,gBAAkBC,uBAAkB,SAAS,gBAAkB;EACjG,GAAG,SAAS,oBAAoB,EAAE,kBAAkBC,2BAAkB,SAAS,kBAAkB"}

package/dist/core/to/settings.js

@@ -0,0 +1,19 @@
+import { getVertexId } from "../util.js";
+import { omitEdgesAndInternalProperties } from "./util.js";
+
+//#region src/core/to/settings.ts
+var settings_default = (settings, options) => {
+	const edges = {
+		period: settings.period ? getVertexId(settings.period, options) : void 0,
+		defaultRootInterval: settings.defaultRootInterval ? getVertexId(settings.defaultRootInterval, options) : void 0
+	};
+	const nonEdges = omitEdgesAndInternalProperties(settings, edges);
+	return {
+		...nonEdges,
+		...edges
+	};
+};
+
+//#endregion
+export { settings_default as default };
+//# sourceMappingURL=settings.js.map

package/dist/core/to/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","names":["edges: SerializedEdgesOnlyVertexExport<DivisionSettingsVertex>"],"sources":["../../../src/core/to/settings.ts"],"sourcesContent":["import type { BaseOptions } from '../../common/types';\nimport type { DivisionSettingsVertex } from '../interfaces/vertices/division-settings';\nimport type { Types } from '../types';\nimport { getVertexId } from '../util';\nimport type { OutTypes } from './schedules';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\n\nexport default (\n  settings: Types.Mixed.Settings,\n  options:  BaseOptions\n): OutTypes.settings => {\n  const edges: SerializedEdgesOnlyVertexExport<DivisionSettingsVertex> = {\n    period:              settings.period              ? getVertexId(settings.period,              options) : undefined,\n    defaultRootInterval: settings.defaultRootInterval ? getVertexId(settings.defaultRootInterval, options) : undefined,\n  } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<DivisionSettingsVertex>>;\n  const nonEdges = omitEdgesAndInternalProperties(settings, edges);\n\n  return { ...nonEdges, ...edges };\n};\n"],"mappings":";;;;AAOA,wBACE,UACA,YACsB;CACtB,MAAMA,QAAiE;EACrE,QAAqB,SAAS,SAAsB,YAAY,SAAS,QAAqB,WAAW;EACzG,qBAAqB,SAAS,sBAAsB,YAAY,SAAS,qBAAqB,WAAW;;CAE3G,MAAM,WAAW,+BAA+B,UAAU;AAE1D,QAAO;EAAE,GAAG;EAAU,GAAG"}

package/dist/core/to/syllabuses.js

@@ -0,0 +1,17 @@
+import { omitEdgesAndInternalProperties } from "./util.js";
+
+//#region src/core/to/syllabuses.ts
+var syllabuses_default = (syllabuses, options) => {
+	return syllabuses.map((x) => {
+		const edges = {};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
+		return {
+			...nonEdges,
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { syllabuses_default as default };
+//# sourceMappingURL=syllabuses.js.map

package/dist/core/to/syllabuses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"syllabuses.js","names":["edges: SerializedEdgesOnlyVertexExport<SyllabusVertex>"],"sources":["../../../src/core/to/syllabuses.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { BaseOptions } from '../../common/types';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { SyllabusVertex } from '../interfaces/vertices/syllabuses';\nimport type { OutTypes } from './schedules';\n\nexport default (\n  syllabuses: Types.Mixed.Syllabus[],\n  options:     BaseOptions\n): OutTypes.syllabus[] => {\n  return syllabuses\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<SyllabusVertex> = {\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<SyllabusVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;AAMA,0BACE,YACA,YACwB;AACxB,QAAO,WACJ,KAAI,MAAK;EACR,MAAMA,QAAyD;EAE/D,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/teachers.js

@@ -0,0 +1,25 @@
+import { getVertexId } from "../util.js";
+import { omitEdgesAndInternalProperties } from "./util.js";
+
+//#region src/core/to/teachers.ts
+var teachers_default = (teachers, options) => {
+	return teachers.map((x) => {
+		const edges = {
+			rootInterval: x.rootInterval ? getVertexId(x.rootInterval, options) : void 0,
+			person: x.person ? getVertexId(x.person, options) : void 0,
+			exceptions: x.exceptions?.map((x$1) => getVertexId(x$1, options)),
+			lockedTimes: x.lockedTimes?.map((x$1) => getVertexId(x$1, options)),
+			lunch: x.lunch?.map((x$1) => getVertexId(x$1, options)),
+			complementaryTimes: x.complementaryTimes?.map((x$1) => getVertexId(x$1, options))
+		};
+		const nonEdges = omitEdgesAndInternalProperties(x, edges);
+		return {
+			...nonEdges,
+			...edges
+		};
+	});
+};
+
+//#endregion
+export { teachers_default as default };
+//# sourceMappingURL=teachers.js.map

package/dist/core/to/teachers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teachers.js","names":["edges: SerializedEdgesOnlyVertexExport<TeacherVertex>","x"],"sources":["../../../src/core/to/teachers.ts"],"sourcesContent":["import type { Types } from '../types';\nimport type { OutTypes } from './schedules';\nimport { getVertexId } from '../util';\nimport { omitEdgesAndInternalProperties, type SerializedEdgesOnlyVertexExport, type SerializedEdgesShape } from './util';\nimport type { BaseOptions } from '../../common/types';\nimport type { TeacherVertex } from '../interfaces/vertices/teachers';\n\nexport default (\n  teachers: Types.Mixed.Teacher[],\n  options:  BaseOptions\n): OutTypes.teacher[] => {\n  return teachers\n    .map(x => {\n      const edges: SerializedEdgesOnlyVertexExport<TeacherVertex> = {\n        rootInterval:       x.rootInterval ? getVertexId(x.rootInterval, options) : undefined,\n        person:             x.person       ? getVertexId(x.person,       options) : undefined,\n        exceptions:         x.exceptions        ?.map(x => getVertexId(x, options)),\n        lockedTimes:        x.lockedTimes       ?.map(x => getVertexId(x, options)),\n        lunch:              x.lunch             ?.map(x => getVertexId(x, options)),\n        complementaryTimes: x.complementaryTimes?.map(x => getVertexId(x, options)),\n      } satisfies SerializedEdgesShape<SerializedEdgesOnlyVertexExport<TeacherVertex>>;\n      const nonEdges = omitEdgesAndInternalProperties(x, edges);\n\n      return { ...nonEdges, ...edges };\n    });\n};\n"],"mappings":";;;;AAOA,wBACE,UACA,YACuB;AACvB,QAAO,SACJ,KAAI,MAAK;EACR,MAAMA,QAAwD;GAC5D,cAAoB,EAAE,eAAe,YAAY,EAAE,cAAc,WAAW;GAC5E,QAAoB,EAAE,SAAe,YAAY,EAAE,QAAc,WAAW;GAC5E,YAAoB,EAAE,YAAoB,KAAI,QAAK,YAAYC,KAAG;GAClE,aAAoB,EAAE,aAAoB,KAAI,QAAK,YAAYA,KAAG;GAClE,OAAoB,EAAE,OAAoB,KAAI,QAAK,YAAYA,KAAG;GAClE,oBAAoB,EAAE,oBAAoB,KAAI,QAAK,YAAYA,KAAG;;EAEpE,MAAM,WAAW,+BAA+B,GAAG;AAEnD,SAAO;GAAE,GAAG;GAAU,GAAG"}

package/dist/core/to/util.d.ts

@@ -0,0 +1,8 @@
+import { Intersect } from "../../common/types.js";
+
+//#region src/core/to/util.d.ts
+declare const keys: readonly ["_id", "createdAt", "updatedAt", "lastModifiedBy", "CONTEXT", "belongsTo", "domain", "derivedParentGroups"];
+type InternalKeysOmitted<V extends object> = Omit<Intersect<V>, typeof keys[number]>;
+//#endregion
+export { InternalKeysOmitted };
+//# sourceMappingURL=util.d.ts.map

package/dist/core/to/util.js

@@ -0,0 +1,25 @@
+import { omit } from "lodash-es";
+
+//#region src/core/to/util.ts
+const keys = [
+	"_id",
+	"createdAt",
+	"updatedAt",
+	"lastModifiedBy",
+	"CONTEXT",
+	"belongsTo",
+	"domain",
+	"derivedParentGroups"
+];
+/**
+* Returns a copy of the vertex with internal keys omitted, such as `_id`, `createdAt`, `updatedAt`, etc.
+* The output type also omits all edges for ease of use.
+*/
+function omitEdgesAndInternalProperties(v, edgesRecord) {
+	const a = omit(v, Object.keys(edgesRecord));
+	return omit(a, keys);
+}
+
+//#endregion
+export { omitEdgesAndInternalProperties };
+//# sourceMappingURL=util.js.map

package/dist/core/to/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","names":[],"sources":["../../../src/core/to/util.ts"],"sourcesContent":["import type { Intersect } from '../../common/types';\nimport type { Collection, SerializedVertexExport, Vertex } from '../interfaces/vertices/util';\nimport type { PickEdges } from '../interfaces/vertices/util/common';\nimport { omit } from 'lodash-es';\n\n\nconst keys =  ['_id',  'createdAt', 'updatedAt', 'lastModifiedBy', 'CONTEXT', 'belongsTo', 'domain', 'derivedParentGroups'] as const;\nexport type InternalKeysOmitted<V extends object> = Omit<Intersect<V>, typeof keys[number]>;\n\nexport type SerializedEdgesOnlyVertexExport<\n  V extends Vertex<Collection>\n> = {\n  [K in keyof SerializedVertexExport<V> as K extends keyof InternalKeysOmitted<PickEdges<V>> ? K : never]: SerializedVertexExport<V>[K]\n};\n\n/**\n *  Used only as `satisfies` to ensure that no edge property is missing.\n */\nexport type SerializedEdgesShape<V extends object> = Record<keyof Omit<V, 'belongsTo'>, unknown>;\n\n/**\n * Returns a copy of the vertex with internal keys omitted, such as `_id`, `createdAt`, `updatedAt`, etc.\n * The output type also omits all edges for ease of use.\n */\nexport function omitEdgesAndInternalProperties <\n  V           extends object,\n  EdgesRecord extends object\n> (v: V, edgesRecord: EdgesRecord) {\n  const a = omit(v, Object.keys(edgesRecord)) as unknown as Omit<V, keyof EdgesRecord>;\n  return omit(a, keys) as unknown as InternalKeysOmitted<typeof a>;\n}\n"],"mappings":";;;AAMA,MAAM,OAAQ;CAAC;CAAQ;CAAa;CAAa;CAAkB;CAAW;CAAa;CAAU;;;;;;AAkBrG,SAAgB,+BAGb,GAAM,aAA0B;CACjC,MAAM,IAAI,KAAK,GAAG,OAAO,KAAK;AAC9B,QAAO,KAAK,GAAG"}

package/dist/core/types/common/index.d.ts

@@ -0,0 +1,8 @@
+import { IDKey, PrivateIDKey, PublicIDKey } from "../../interfaces/vertices/util/vertex.js";
+
+//#region src/core/types/common/index.d.ts
+type IdKey = IDKey | PrivateIDKey | PublicIDKey;
+type InternalIdKey = Exclude<IdKey, PublicIDKey>;
+//#endregion
+export { IdKey, InternalIdKey };
+//# sourceMappingURL=index.d.ts.map

package/dist/core/types/common/meta.d.ts

@@ -0,0 +1,15 @@
+//#region src/core/types/common/meta.d.ts
+interface Meta {
+  structure?: `RS/core-${number}.${number}.${number}`;
+  warnings?: (string | {
+    code: string;
+    context?: any;
+  })[];
+  errors?: (string | {
+    code: string;
+    context?: any;
+  })[];
+}
+//#endregion
+export { Meta };
+//# sourceMappingURL=meta.d.ts.map

package/dist/core/types/index.d.ts

@@ -0,0 +1,136 @@
+import { Meta } from "./common/meta.js";
+import { Day } from "../interfaces/vertices/properties/days.js";
+import { Interval } from "../interfaces/vertices/properties/intervals.js";
+import { MinBreakLength } from "../interfaces/vertices/properties/min-break-length.js";
+import { Deep, Mixed, MixedWithOptionalId, Serialized, SerializedWithOptionalId } from "../interfaces/vertices/index.js";
+
+//#region src/core/types/index.d.ts
+declare namespace Types {
+  type breakLength = MinBreakLength;
+  type day = Day;
+  type interval = Interval;
+  type meta = Meta;
+  namespace Deep {
+    type Configuration = Deep.Configuration.Base;
+    type Teacher = Deep.Teacher;
+    type Exception = Deep.Exception;
+    type Event = Deep.Event;
+    type ScheduleEvent = Deep.ScheduleEvent;
+    type CalendarEvent = Deep.CalendarEvent;
+    type Course = Deep.Course;
+    type Settings = Deep.Settings;
+    type Division = Deep.Division;
+    type Generation = Deep.Generation;
+    type Group = Deep.Group;
+    type Location = Deep.Location;
+    type LockedTime = Deep.LockedTime;
+    type OverlapGroup = Deep.OverlapGroup;
+    type LinkedEventsSet = Deep.LinkedEventsSet;
+    type Period = Deep.Period;
+    type Person = Deep.Person;
+    type RootInterval = Deep.RootInterval;
+    type Syllabus = Deep.Syllabus;
+    type User = Deep.User;
+    type Thread = Deep.Thread;
+    type Schedule = Deep.Schedule;
+  }
+  namespace Serialized {
+    type Configuration = Serialized.Configuration.Base;
+    type Teacher = Serialized.Teacher;
+    type Exception = Serialized.Exception;
+    type Event = Serialized.Event;
+    type ScheduleEvent = Serialized.ScheduleEvent;
+    type CalendarEvent = Serialized.CalendarEvent;
+    type Course = Serialized.Course;
+    type Settings = Serialized.Settings;
+    type Division = Serialized.Division;
+    type Generation = Serialized.Generation;
+    type Group = Serialized.Group;
+    type Location = Serialized.Location;
+    type LockedTime = Serialized.LockedTime;
+    type OverlapGroup = Serialized.OverlapGroup;
+    type LinkedEventsSet = Serialized.LinkedEventsSet;
+    type Period = Serialized.Period;
+    type Person = Serialized.Person;
+    type RootInterval = Serialized.RootInterval;
+    type Syllabus = Serialized.Syllabus;
+    type User = Serialized.User;
+    type Thread = Serialized.Thread;
+    type Schedule = Serialized.Schedule;
+  }
+  namespace Mixed {
+    type Configuration = Mixed.Configuration.Base;
+    type Teacher = Mixed.Teacher;
+    type Exception = Mixed.Exception;
+    type Event = Mixed.Event;
+    type ScheduleEvent = Mixed.ScheduleEvent;
+    type CalendarEvent = Mixed.CalendarEvent;
+    type Course = Mixed.Course;
+    type Settings = Mixed.Settings;
+    type Division = Mixed.Division;
+    type Generation = Mixed.Generation;
+    type Group = Mixed.Group;
+    type Location = Mixed.Location;
+    type LockedTime = Mixed.LockedTime;
+    type OverlapGroup = Mixed.OverlapGroup;
+    type LinkedEventsSet = Mixed.LinkedEventsSet;
+    type Period = Mixed.Period;
+    type Person = Mixed.Person;
+    type RootInterval = Mixed.RootInterval;
+    type Syllabus = Mixed.Syllabus;
+    type User = Mixed.User;
+    type Thread = Mixed.Thread;
+    type Schedule = Mixed.Schedule;
+  }
+  namespace MixedWithoutInternalId {
+    type Configuration = MixedWithOptionalId.Configuration.Base;
+    type Teacher = MixedWithOptionalId.Teacher;
+    type Exception = MixedWithOptionalId.Exception;
+    type Event = MixedWithOptionalId.Event;
+    type ScheduleEvent = MixedWithOptionalId.ScheduleEvent;
+    type CalendarEvent = MixedWithOptionalId.CalendarEvent;
+    type Course = MixedWithOptionalId.Course;
+    type Settings = MixedWithOptionalId.Settings;
+    type Division = MixedWithOptionalId.Division;
+    type Generation = MixedWithOptionalId.Generation;
+    type Group = MixedWithOptionalId.Group;
+    type Location = MixedWithOptionalId.Location;
+    type LockedTime = MixedWithOptionalId.LockedTime;
+    type OverlapGroup = MixedWithOptionalId.OverlapGroup;
+    type LinkedEventsSet = MixedWithOptionalId.LinkedEventsSet;
+    type Period = MixedWithOptionalId.Period;
+    type Person = MixedWithOptionalId.Person;
+    type RootInterval = MixedWithOptionalId.RootInterval;
+    type Syllabus = MixedWithOptionalId.Syllabus;
+    type User = MixedWithOptionalId.User;
+    type Thread = MixedWithOptionalId.Thread;
+    type Schedule = MixedWithOptionalId.Schedule;
+  }
+  namespace SerializedWithOptionalId {
+    type Configuration = SerializedWithOptionalId.Configuration.Base;
+    type Teacher = SerializedWithOptionalId.Teacher;
+    type Exception = SerializedWithOptionalId.Exception;
+    type Event = SerializedWithOptionalId.Event;
+    type ScheduleEvent = SerializedWithOptionalId.ScheduleEvent;
+    type CalendarEvent = SerializedWithOptionalId.CalendarEvent;
+    type Course = SerializedWithOptionalId.Course;
+    type Settings = SerializedWithOptionalId.Settings;
+    type Division = SerializedWithOptionalId.Division;
+    type Generation = SerializedWithOptionalId.Generation;
+    type Group = SerializedWithOptionalId.Group;
+    type Location = SerializedWithOptionalId.Location;
+    type LockedTime = SerializedWithOptionalId.LockedTime;
+    type OverlapGroup = SerializedWithOptionalId.OverlapGroup;
+    type LinkedEventsSet = SerializedWithOptionalId.LinkedEventsSet;
+    type Period = SerializedWithOptionalId.Period;
+    type Person = SerializedWithOptionalId.Person;
+    type RootInterval = SerializedWithOptionalId.RootInterval;
+    type Syllabus = SerializedWithOptionalId.Syllabus;
+    type User = SerializedWithOptionalId.User;
+    type Thread = SerializedWithOptionalId.Thread;
+    type Schedule = SerializedWithOptionalId.Schedule;
+  }
+}
+//#endregion
+export { Types };
+//# sourceMappingURL=index.d.ts.map

package/dist/core/util.js

@@ -0,0 +1,47 @@
+import { isMongooseObjectId } from "../common/functions.js";
+import moment from "moment";
+
+//#region src/core/util.ts
+/**
+* Returns the ID key to use for vertices, which can be either `id`, `_id`, or `ids`.
+*/
+function getIdKey({ idKey }) {
+	return idKey ?? "id";
+}
+/**
+* Returns the ID of a vertex, which can be either `_id`, `id`, or `ids`.
+*/
+function getVertexId(edge, _idKey) {
+	if (typeof edge === "string") return edge;
+	if (isMongooseObjectId(edge)) return edge.toString();
+	if (typeof edge !== "object" || edge === null) throw new Error(`Unable to get vertex ID from edge: ${JSON.stringify(edge)}`);
+	const idKey = typeof _idKey === "string" ? _idKey : getIdKey(_idKey);
+	if (idKey == "_id" && idKey in edge && edge[idKey]) return edge[idKey].toString();
+	if (idKey == "id" && idKey in edge && edge[idKey]) return edge[idKey];
+	if (idKey == "ids" && idKey in edge && edge[idKey]) return edge[idKey];
+	throw new Error(`Unable to get vertex ID "${idKey}" from edge: ${JSON.stringify(edge)}`);
+}
+/**
+* Returns the day index in the range 0-6, where 0 is Monday and 6 is Sunday.
+*/
+function getDayIndex(value) {
+	const day = typeof value === "number" ? value : moment.utc(value).day();
+	return (day + 6) % 7;
+}
+function parseDateInterval(interval, type) {
+	if (!interval.start) throw new Error(`(RS::To::validateInterval) The interval ${type ? `"${type}"` : ""} is missing a start time`);
+	if (!interval.end) throw new Error(`(RS::To::validateInterval) The interval ${type ? `"${type}"` : ""} is missing an end time`);
+	const start = moment.utc(interval.start);
+	const end = moment.utc(interval.end);
+	if (!start.isValid()) throw new Error(`(RS::To::validateInterval) The interval ${type ? `"${type}"` : ""} has an invalid start time`);
+	if (!end.isValid()) throw new Error(`(RS::To::validateInterval) The interval ${type ? `"${type}"` : ""} has an invalid end time`);
+	if (end.isSameOrBefore(start)) throw new Error(`(RS::To::validateInterval) The interval ${type ? `"${type}"` : ""} is invalid: end time is before or equal to start time`);
+	return {
+		start,
+		end
+	};
+}
+
+//#endregion
+export { getDayIndex, getIdKey, getVertexId, parseDateInterval };
+//# sourceMappingURL=util.js.map

package/dist/core/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","names":[],"sources":["../../src/core/util.ts"],"sourcesContent":["import moment from 'moment';\nimport { isMongooseObjectId } from '../common/functions';\nimport type { IdKey } from './types/common';\nimport type { Vertex, Collection } from './interfaces/vertices/util';\nimport type { DateType } from '../common/types';\nimport type { Interval } from './interfaces';\nimport type { IDType, OmitInternalVertexKeys, PrivateIDType } from './interfaces/vertices/util/vertex';\n\n/**\n * Returns the ID key to use for vertices, which can be either `id`, `_id`, or `ids`.\n */\nexport function getIdKey ({ idKey }: { idKey?: IdKey }) {\n  return idKey ?? 'id';\n}\n\n/**\n * Returns the ID of a vertex, which can be either `_id`, `id`, or `ids`.\n */\nexport function getVertexId (\n  edge:   IDType | PrivateIDType | Partial<OmitInternalVertexKeys<Vertex<Collection>>>,\n  _idKey: IdKey | { idKey?: IdKey }\n): string {\n  if (typeof edge === 'string') return edge;\n  if (isMongooseObjectId(edge)) return edge.toString();\n\n  // the edge must be an object at this point\n  if (typeof edge !== 'object' || edge === null) {\n    throw new Error(`Unable to get vertex ID from edge: ${JSON.stringify(edge)}`);\n  }\n\n  const idKey = typeof _idKey === 'string' ? _idKey : getIdKey(_idKey);\n  if (idKey == '_id' && idKey in edge && edge[idKey]) return edge[idKey].toString();\n  if (idKey == 'id'  && idKey in edge && edge[idKey]) return edge[idKey];\n  if (idKey == 'ids' && idKey in edge && edge[idKey]) return edge[idKey];\n\n  throw new Error(`Unable to get vertex ID \"${idKey}\" from edge: ${JSON.stringify(edge)}`);\n}\n\n\n/**\n * Returns the day index in the range 0-6, where 0 is Monday and 6 is Sunday.\n */\nexport function getDayIndex (value: DateType | number): number {\n  const day = typeof value === 'number' ? value : moment.utc(value).day();\n  return (day + 6) % 7;\n}\n\nexport function parseDateInterval (interval: Partial<Interval<DateType>>, type?: string): Interval<moment.Moment> {\n  if (!interval.start) throw new Error(`(RS::To::validateInterval) The interval ${type ? `\"${type}\"` : ''} is missing a start time`);\n  if (!interval.end  ) throw new Error(`(RS::To::validateInterval) The interval ${type ? `\"${type}\"` : ''} is missing an end time`);\n\n  const start = moment.utc(interval.start);\n  const end   = moment.utc(interval.end);\n  if (!start.isValid()) throw new Error(`(RS::To::validateInterval) The interval ${type ? `\"${type}\"` : ''} has an invalid start time`);\n  if (!end  .isValid()) throw new Error(`(RS::To::validateInterval) The interval ${type ? `\"${type}\"` : ''} has an invalid end time`);\n\n  if (end.isSameOrBefore(start)) throw new Error(`(RS::To::validateInterval) The interval ${type ? `\"${type}\"` : ''} is invalid: end time is before or equal to start time`);\n\n  return { start, end };\n}"],"mappings":";;;;;;;AAWA,SAAgB,SAAU,EAAE,SAA4B;AACtD,QAAO,SAAS;;;;;AAMlB,SAAgB,YACd,MACA,QACQ;AACR,KAAI,OAAO,SAAS,SAAU,QAAO;AACrC,KAAI,mBAAmB,MAAO,QAAO,KAAK;AAG1C,KAAI,OAAO,SAAS,YAAY,SAAS,KACvC,OAAM,IAAI,MAAM,sCAAsC,KAAK,UAAU;CAGvE,MAAM,QAAQ,OAAO,WAAW,WAAW,SAAS,SAAS;AAC7D,KAAI,SAAS,SAAS,SAAS,QAAQ,KAAK,OAAQ,QAAO,KAAK,OAAO;AACvE,KAAI,SAAS,QAAS,SAAS,QAAQ,KAAK,OAAQ,QAAO,KAAK;AAChE,KAAI,SAAS,SAAS,SAAS,QAAQ,KAAK,OAAQ,QAAO,KAAK;AAEhE,OAAM,IAAI,MAAM,4BAA4B,MAAM,eAAe,KAAK,UAAU;;;;;AAOlF,SAAgB,YAAa,OAAkC;CAC7D,MAAM,MAAM,OAAO,UAAU,WAAW,QAAQ,OAAO,IAAI,OAAO;AAClE,SAAQ,MAAM,KAAK;;AAGrB,SAAgB,kBAAmB,UAAuC,MAAwC;AAChH,KAAI,CAAC,SAAS,MAAO,OAAM,IAAI,MAAM,2CAA2C,OAAO,IAAI,KAAK,KAAK,GAAG;AACxG,KAAI,CAAC,SAAS,IAAO,OAAM,IAAI,MAAM,2CAA2C,OAAO,IAAI,KAAK,KAAK,GAAG;CAExG,MAAM,QAAQ,OAAO,IAAI,SAAS;CAClC,MAAM,MAAQ,OAAO,IAAI,SAAS;AAClC,KAAI,CAAC,MAAM,UAAW,OAAM,IAAI,MAAM,2CAA2C,OAAO,IAAI,KAAK,KAAK,GAAG;AACzG,KAAI,CAAC,IAAM,UAAW,OAAM,IAAI,MAAM,2CAA2C,OAAO,IAAI,KAAK,KAAK,GAAG;AAEzG,KAAI,IAAI,eAAe,OAAQ,OAAM,IAAI,MAAM,2CAA2C,OAAO,IAAI,KAAK,KAAK,GAAG;AAElH,QAAO;EAAE;EAAO"}

package/dist/identify/constants/index.d.ts

@@ -0,0 +1,144 @@
+import { CoreMap } from "../../core/index.js";
+import { Map } from "../../Skola24/txt/index.js";
+import { Event } from "../../SchoolSoft/file/types/events.js";
+import { Map as Map$1 } from "../../Skola24/mdb/index.js";
+import { Map as Map$2 } from "../../Excel/v1/index.js";
+import { Map as Map$3 } from "../../Excel/v2/index.js";
+import { SchoolSoftMap } from "../../SchoolSoft/index.js";
+import { PlanDigitalMap } from "../../PlanDigital/index.js";
+import { AdmentumMap } from "../../Admentum/index.js";
+import { IdunSoftMap } from "../../IdunSoft/index.js";
+import { RSMap } from "../../RS/index.js";
+
+//#region src/identify/constants/index.d.ts
+declare const maps: readonly [{
+  readonly structure: null;
+  readonly matchType: "string";
+  readonly name: "Skola24 (txt)";
+  readonly map: typeof Map;
+  readonly meta: {
+    readonly structure: "";
+  };
+}, {
+  readonly structure: {
+    schools: string[];
+    schedule: string[];
+    rooms: string[];
+    teachers: string[];
+    principals: string[];
+    courses: string[];
+    schedule_groups: string[];
+    primary_groups: string[];
+    schedule_events: string[];
+    schedule_event_instances: string[];
+    lessons: string[];
+    lesson_infos: string[];
+  };
+  readonly name: "Admentum";
+  readonly map: typeof AdmentumMap;
+  readonly meta: {
+    readonly structure: "";
+  };
+}, {
+  readonly structure: (keyof Event)[];
+  readonly name: "SchoolSoft";
+  readonly map: typeof SchoolSoftMap;
+  readonly meta: {
+    readonly structure: "";
+  };
+}, {
+  readonly structure: {
+    Perioder: string[];
+    'Tabell Tj\u00E4nstef\u00F6rdelning': string[];
+  };
+  readonly name: "Plan Digital";
+  readonly map: typeof PlanDigitalMap;
+  readonly meta: {
+    readonly structure: "";
+  };
+}, {
+  readonly structure: {
+    Grupp: string[];
+    Lärare: string[];
+    Rum: string[];
+    Ämne: string[];
+    Lektion: string[];
+  };
+  readonly name: "IdunSoft";
+  readonly map: typeof IdunSoftMap;
+  readonly meta: {
+    readonly structure: "";
+  };
+}, {
+  readonly structure: {
+    unit_tblroom: string[];
+    school_tblsubject: string[];
+    school_tblteacher: string[];
+    school_tblgroup: string[];
+    school_tblplan: string[];
+    school_tblcourse: never[];
+    school_tblschedule: string[];
+    school_tblgroup_group: string[];
+    school_tblplan_period: string[];
+    school_tblplan_teacher: string[];
+    school_tblplan_group: string[];
+    unit_tblperiod_date: string[];
+    school_tblschedule_period: string[];
+    school_tblschedule_teacher: string[];
+    school_tblschedule_group: string[];
+    school_tblschedule_room: string[];
+  };
+  readonly name: "Skola24 (mdb)";
+  readonly map: typeof Map$1;
+  readonly meta: {
+    readonly structure: "";
+  };
+}, {
+  readonly structure: {
+    events: string[];
+  };
+  readonly name: "Royal Schedule Algorithm";
+  readonly map: typeof RSMap;
+  readonly meta: {
+    readonly structure: "RS/algorithm-6.0.0";
+  };
+}, {
+  readonly structure: {
+    groups: string[];
+    locations: string[];
+    teachers: string[];
+    courses: string[];
+  };
+  readonly name: "Royal Schedule";
+  readonly map: typeof CoreMap;
+  readonly meta: {
+    readonly structure: "RS/core-2.0.0";
+  };
+}, {
+  readonly structure: {
+    meta: string[][];
+    courses: never[];
+    groups: never[];
+    locations: never[];
+  };
+  readonly name: "Royal Schedule Excel";
+  readonly map: typeof Map$2;
+  readonly meta: {
+    readonly structure: "RS/Excel-1.0.0";
+  };
+}, {
+  readonly structure: {
+    meta: string[][];
+    courses: never[];
+    groups: never[];
+    locations: never[];
+  };
+  readonly name: "Royal Schedule Excel";
+  readonly map: typeof Map$3;
+  readonly meta: {
+    readonly structure: "RS/Excel-2.0.0";
+  };
+}];
+//#endregion
+export { maps };
+//# sourceMappingURL=index.d.ts.map