@royalschedule/maps 2.2.76 → 2.2.78

package/dist/core/types/course-events.d.ts

@@ -1,5 +1,6 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
@@ -12,36 +13,38 @@ import { Location } from './locations';
 import { AvailableLocation } from './available-locations';
 import { OverlapGroup } from './overlap-groups';
 export interface CourseEventBare {
-    belongsTo?: Division;
-    course?: Course | string;
-    groups?: Group[] | string[] | null;
-    teachers?: Teacher[] | string[] | null;
-    locations?: AvailableLocation[] | AvailableLocation[][] | string[] | null;
-    inLocations?: Location[] | string[];
-    weeks?: number[];
+    belongsTo?: Edge<Division>;
+    course?: Edge<Course>;
+    groups?: Edge<Group[]> | null;
+    teachers?: Edge<Teacher[]> | null;
+    locations?: AvailableLocation[] | null;
+    inLocations?: Edge<Location[]>;
     density?: number;
     weight?: number;
     potentialCenter?: string;
     parked?: boolean;
     color?: string;
     fixedStart?: boolean;
-    start?: moment.Moment | string;
-    end?: moment.Moment | string;
+    start?: moment.Moment | string | Date;
+    end?: moment.Moment | string | Date;
     ids?: string;
     minBreakLength?: BreakLength;
+    weeks?: number[];
+    type?: string;
     displayName?: string;
     visible?: boolean;
     duration?: number;
-    preferredDuration: number;
+    preferredDuration?: number;
     durationVariance?: number;
-    lockedTimes?: LockedTime[];
+    lockedTimes?: Edge<LockedTime[]> | null;
     intervals?: Interval[];
+    centerOfAttraction?: string | null;
     days?: Day[] | null;
-    overlapGroup?: OverlapGroup;
-    overlapSpecies?: OverlapGroup | null;
-    centerOfAttraction?: string;
+    overlapGroup?: Edge<OverlapGroup> | null;
+    overlapSpecies?: Edge<OverlapGroup> | null;
     createdAt?: string;
     updatedAt?: string;
+    lastModifiedBy?: unknown;
 }
 export interface CourseEvent extends CourseEventBare {
     _id?: Types.ObjectId;

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

@@ -1,4 +1,5 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
@@ -10,32 +11,34 @@ import { AvailableLocation } from './available-locations';
 import { CourseEvent } from './course-events';
 import { OverlapGroup } from './overlap-groups';
 export interface CourseBare {
-    belongsTo?: Division;
-    events?: CourseEvent[] | string[];
-    groups?: Group[] | string[] | null;
-    teachers?: Teacher[] | string[] | null;
-    locations?: AvailableLocation[] | AvailableLocation[][] | string[] | null;
+    belongsTo?: Edge<Division>;
+    events?: Edge<CourseEvent[]>;
+    groups?: Edge<Group[]>;
+    teachers?: Edge<Teacher[]>;
+    locations?: AvailableLocation[];
     density?: number;
     weight?: number;
     potentialCenter?: string;
     ids?: string;
     subject?: string;
     minBreakLength?: BreakLength;
+    weeks?: number[];
     displayName?: string;
     color?: string;
+    eventDurationVariance?: number;
     totalTime?: string;
     type?: string;
-    lockedTimes?: LockedTime[] | string[];
+    lockedTimes?: Edge<LockedTime[]>;
     intervals?: Interval[];
+    centerOfAttraction?: string | null;
     days?: Day[];
-    overlapGroup?: OverlapGroup;
-    overlapSpecies?: OverlapGroup | null;
-    eventDurationVariance?: number;
-    centerOfAttraction?: string;
+    overlapGroup?: Edge<OverlapGroup> | null;
+    overlapSpecies?: Edge<OverlapGroup> | null;
     minutesPerWeek?: number;
     expectedTotalHours?: number;
     createdAt?: string;
     updatedAt?: string;
+    lastModifiedBy?: unknown;
 }
 export interface Course extends CourseBare {
     _id?: Types.ObjectId;

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

@@ -1,11 +1,7 @@
 import { Types } from 'mongoose';
-import { Division } from './divisions';
 export interface DayBare {
-    belongsTo?: Division;
     day?: number;
     rank?: number;
-    to?: Types.ObjectId;
-    toModel?: string;
 }
 export interface Day extends DayBare {
     _id?: Types.ObjectId;

package/dist/core/types/division-settings.d.ts

@@ -1,28 +1,29 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { LockedTime } from './locked-times';
 export interface DivisionSettingsBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     createdAt?: string;
+    discretization: number;
     numDays: number;
-    discretization?: number;
-    dayStart?: string;
-    dayEnd?: string;
-    defaultDependencyMinimumBreakLength?: number;
+    dayStart: string;
+    dayEnd: string;
+    potentialCenter?: string;
     defaultGroupMinimumBreakLength?: number;
     defaultEventMinimumBreakLength?: number;
-    potentialCenter?: string;
-    defaultEventDensity?: number;
-    defaultEventDurationVariance?: number;
-    defaultMaxNumWorkingHours?: number | boolean;
-    defaultMaxNumDailyWorkingHours?: number | boolean;
+    defaultDependencyMinimumBreakLength?: number;
+    defaultMaxNumWorkingHours?: number | boolean | any;
+    defaultMaxNumDailyWorkingHours?: number | boolean | any;
     defaultDayRank?: number;
-    defaultDependencyRank?: number;
     defaultGroupRank?: number;
+    defaultDependencyRank?: number;
+    defaultEventDensity?: number;
     defaultEventWeight?: number;
     defaultGroupWeight?: number;
     defaultCourseWeight?: number;
-    defaultLunch?: Pick<LockedTime, 'intervals' | 'duration' | 'durationVariance'>[];
+    defaultEventDurationVariance?: number;
+    defaultLunch?: Edge<LockedTime[]>;
 }
 export interface DivisionSettings extends DivisionSettingsBare {
     _id?: Types.ObjectId;

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

@@ -1,30 +1,38 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
+import { Edge } from './common';
 import { Area } from './areas';
 import { Course } from './courses';
 import { CourseEvent } from './course-events';
 import { DivisionSettings } from './division-settings';
 import { Group } from './groups';
 import { Location } from './locations';
+import { LockedTime } from './locked-times';
 import { OverlapGroup } from './overlap-groups';
+import { Person } from './persons';
 import { Teacher } from './teachers';
 import { Meta } from './meta';
-export interface DivisionBare {
-    displayName?: string;
+export interface VirtualDivisionFields {
     groups?: Group[];
     teachers?: Teacher[];
     locations?: Location[];
+    courses?: Course[];
     events?: CourseEvent[];
+    persons?: Person[];
     overlapGroups?: OverlapGroup[];
-    courses?: Course[];
+    lockedTimes?: LockedTime[];
     area?: Area;
+}
+export interface DivisionBare {
+    settings?: Edge<DivisionSettings>;
+    displayName?: string;
     start?: moment.Moment | string | Date;
     end?: moment.Moment | string | Date;
-    settings?: DivisionSettings;
+    editedAt?: moment.Moment | string | Date;
     createdAt?: string;
     meta?: Meta;
 }
-export interface Division extends DivisionBare {
+export interface Division extends DivisionBare, VirtualDivisionFields {
     _id?: Types.ObjectId;
     id?: string;
 }

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

@@ -1,11 +1,12 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
 import { Interval } from './intervals';
 import { Day } from './days';
 export interface GroupBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     ids?: string;
     displayName?: string;
     minBreakLength?: BreakLength;
@@ -14,12 +15,14 @@ export interface GroupBare {
     forbidOverlappingEvents?: boolean;
     disableDayLengthPunishment?: boolean;
     weight?: number;
-    lockedTimes?: LockedTime[];
-    lunch?: LockedTime[] | null;
+    rank?: number;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
     intervals?: Interval[];
     days?: Day[];
     createdAt?: string;
     updatedAt?: string;
+    lastModifiedBy?: unknown;
 }
 export interface Group extends GroupBare {
     _id?: Types.ObjectId;

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

@@ -1,10 +1,8 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
-import { Division } from './divisions';
 export interface IntervalBare {
-    belongsTo?: Division;
-    start?: moment.Moment | string;
-    end?: moment.Moment | string;
+    start?: moment.Moment | string | Date;
+    end?: moment.Moment | string | Date;
     day?: number;
     type?: string;
 }

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

@@ -1,20 +1,25 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { LockedTime } from './locked-times';
 import { Interval } from './intervals';
 import { Day } from './days';
 export interface LocationBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     ids?: string;
-    displayName?: string;
+    rank?: number;
     seats?: number;
-    lockedTimes?: LockedTime[];
+    displayName?: string;
+    text?: string;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
     intervals?: Interval[];
     days?: Day[];
     area?: string;
     minBreakLength?: number;
     createdAt?: string;
     updatedAt?: string;
+    lastModifiedBy?: unknown;
 }
 export interface Location extends LocationBare {
     _id?: Types.ObjectId;

package/dist/core/types/locked-times.d.ts

@@ -1,22 +1,32 @@
 import { Types } from 'mongoose';
 import moment from 'moment';
+import { Edge } from './common';
+import { Coalesced } from './common/coalesced';
 import { Division } from './divisions';
 import { Interval } from './intervals';
-import { Coalesced } from './common/coalesced';
+import { Day } from './days';
+import { Teacher } from './teachers';
+import { Course } from './courses';
+import { CourseEvent } from './course-events';
+import { Person } from './persons';
+import { Location } from './locations';
 export interface LockedTimeBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     displayName?: string;
-    start?: moment.Moment | string;
-    end?: moment.Moment | string;
+    color?: string;
+    type?: 'LUNCH' | 'ANY';
+    start?: moment.Moment | Date | string;
+    end?: moment.Moment | Date | string;
     visible?: boolean;
     parked?: boolean;
-    day?: number;
-    coalesced?: Coalesced[];
     duration?: number;
     durationVariance?: number;
+    coalesced?: Coalesced<Teacher | Course | CourseEvent | Location | Person>[];
     intervals?: Interval[];
+    days?: Day[];
     createdAt?: string;
-    type?: 'LUNCH' | 'ANY';
+    updatedAt?: string;
+    lastModifiedBy?: unknown;
 }
 export interface LockedTime extends LockedTimeBare {
     _id?: Types.ObjectId;

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

@@ -1,4 +1,5 @@
 export interface Meta {
+    structure?: 'RS/core-1.0.0';
     warnings?: string[];
     errors?: string[];
 }

package/dist/core/types/overlap-groups.d.ts

@@ -1,14 +1,19 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { Coalesced } from './common/coalesced';
+import { Course } from './courses';
+import { CourseEvent } from './course-events';
 export interface OverlapGroupBare {
-    belongsTo?: Division | Types.ObjectId;
+    belongsTo?: Edge<Division>;
     ids?: string;
-    coalesced?: Coalesced[];
-    species?: (Coalesced & {
+    coalesced?: Coalesced<Course>[];
+    species?: (Coalesced<CourseEvent> & {
         id?: string;
     })[];
     createdAt?: string;
+    updatedAt?: string;
+    lastModifiedBy?: unknown;
 }
 export interface OverlapGroup extends OverlapGroupBare {
     _id?: Types.ObjectId;

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

@@ -0,0 +1,19 @@
+import { Types } from 'mongoose';
+import { Edge } from './common';
+import { Division } from './divisions';
+import { LockedTime } from './locked-times';
+export interface PersonBare {
+    belongsTo?: Edge<Division>;
+    ids?: string;
+    displayName?: string;
+    lastname?: string;
+    firstname?: string;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface Person extends PersonBare {
+    _id?: Types.ObjectId;
+    id?: string;
+}

package/dist/{Skola24/types/Meta.js → core/types/persons.js}

@@ -3,4 +3,4 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-//# sourceMappingURL=Meta.js.map
+//# sourceMappingURL=persons.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"persons.js","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

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

@@ -1,11 +1,12 @@
 import { Types } from 'mongoose';
+import { Edge } from './common';
 import { Division } from './divisions';
 import { BreakLength } from './break-lengths';
 import { LockedTime } from './locked-times';
 import { Interval } from './intervals';
 import { Day } from './days';
 export interface TeacherBare {
-    belongsTo?: Division;
+    belongsTo?: Edge<Division>;
     ids?: string;
     displayName?: string;
     lastname?: string;
@@ -16,8 +17,8 @@ export interface TeacherBare {
     forbidOverlappingEvents?: boolean;
     disableDayLengthPunishment?: boolean;
     weight?: number;
-    lockedTimes?: LockedTime[];
-    lunch?: LockedTime[] | null;
+    lockedTimes?: Edge<LockedTime[]>;
+    lunch?: Edge<LockedTime[]>;
     intervals?: Interval[];
     days?: Day[];
     rank?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@royalschedule/maps",
-  "version": "2.2.76",
+  "version": "2.2.78",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,7 +47,7 @@
     "nodemon": "^2.0.19",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.8.3"
+    "typescript": "^4.7.4"
   },
   "dependencies": {
     "app-module-path": "^2.2.0",

package/dist/PlanDigital/types/course.d.ts

@@ -1,15 +0,0 @@
-export interface Course {
-    Klass: string;
-    Kurskod: string;
-    Sign: string;
-    Poäng: number;
-    Ht: number;
-    Resurs: 0 | 1;
-    Vt: number;
-    Summa: number;
-    Period: 'LÅ' | 'Vt' | 'Ht';
-    Anteckningar: string;
-    Antal: number;
-    Ämne: string;
-    Kursnamn: string;
-}

package/dist/PlanDigital/types/course.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=course.js.map

package/dist/PlanDigital/types/course.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"course.js","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/dist/Skola24/types/Meta.d.ts

@@ -1,7 +0,0 @@
-export interface Meta {
-    week?: number;
-    ignoreEmptyCourses?: boolean;
-    deduceGroupsFromCourseName?: boolean;
-    removeUnreferencedTeachers?: boolean;
-    removeUnreferencedGroups?: boolean;
-}

package/dist/Skola24/types/Meta.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Meta.js","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

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

@@ -1,63 +0,0 @@
-import { CoreMap } from '../index';
-import { SchoolSoftMap } from '../../SchoolSoft/file';
-import { PlanDigitalMap } from '../../PlanDigital';
-import { IdunSoftMap } from '../../IdunSoft';
-import { Skola24Map } from '../../Skola24';
-import { RSMap } from '../../RS';
-export declare const maps: readonly [{
-    readonly structure: (keyof import("../../SchoolSoft/file/types/events").Event)[];
-    readonly name: "SchoolSoft";
-    readonly map: typeof SchoolSoftMap;
-    readonly meta: {
-        readonly structure: "";
-    };
-}, {
-    readonly structure: (keyof import("../../PlanDigital/types/course").Course)[];
-    readonly name: "Plan Digital";
-    readonly map: typeof PlanDigitalMap;
-    readonly meta: {
-        readonly structure: "";
-    };
-}, {
-    readonly structure: any;
-    readonly name: "IdunSoft";
-    readonly map: typeof IdunSoftMap;
-    readonly meta: {
-        readonly structure: "";
-    };
-}, {
-    readonly structure: any;
-    readonly name: "Skola24";
-    readonly map: typeof Skola24Map;
-    readonly meta: {
-        readonly structure: "";
-    };
-}, {
-    readonly structure: any;
-    readonly name: "Royal Schedule Algorithm v0";
-    readonly map: typeof RSMap;
-    readonly meta: {
-        readonly structure: "RS/algorithm-0.1.3";
-    };
-}, {
-    readonly structure: any;
-    readonly name: "Royal Schedule Algorithm v1";
-    readonly map: typeof import("../../RS/v1").V1;
-    readonly meta: {
-        readonly structure: "RS/algorithm-1.0.0";
-    };
-}, {
-    readonly structure: any;
-    readonly name: "Royal Schedule Algorithm v2";
-    readonly map: typeof import("../../RS/v2").V2;
-    readonly meta: {
-        readonly structure: "RS/algorithm-2.0.0";
-    };
-}, {
-    readonly structure: any;
-    readonly name: "Royal Schedule";
-    readonly map: typeof CoreMap;
-    readonly meta: {
-        readonly structure: "RS/core-1.0.0";
-    };
-}];

package/dist/core/constants/index.js

@@ -1,121 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.maps = void 0;
-
-var _index = require("../index");
-
-var _file = require("../../SchoolSoft/file");
-
-var _PlanDigital = require("../../PlanDigital");
-
-var _IdunSoft = require("../../IdunSoft");
-
-var _Skola = require("../../Skola24");
-
-var _RS = require("../../RS");
-
-var core_structure = {
-  groups: ['id'],
-  locations: ['id'],
-  teachers: ['id'],
-  courses: ['id', 'events', 'groups', 'subject', 'teachers']
-};
-var RS0_structure = {
-  input: ['courses', 'dependencies', 'settings', 'groups', 'teachers'],
-  output: ['course', 'day', 'dependencies', 'end', 'id', 'start']
-};
-var RS1_structure = {
-  events: ['collection', 'day', 'dependencies', 'end', 'id', 'start']
-};
-var RS2_structure = {
-  events: ['collection', 'day', 'dependencies', 'end', 'id', 'start']
-};
-var IdunSoft_structure = {
-  Grupp: ['ID', 'Klassnamn'],
-  Lärare: ['ID', 'Namn'],
-  Rum: ['ID', 'Namn'],
-  Ämne: ['Ämne', 'Betygskod'],
-  Lektion: ['LektionID', 'Ämne', 'Starttid', 'Sluttid', 'Lektionslängd', 'LärareID', 'GruppID', 'RumID', 'VeckodagID']
-};
-var Skola24_structure = {
-  unit_tblroom: ['PK', 'ID'],
-  school_tblsubject: ['PK', 'ID'],
-  school_tblteacher: ['PK', 'ID'],
-  school_tblgroup: ['PK', 'ID', 'bClass'],
-  school_tblplan: ['PK', 'FKSubject'],
-  school_tblcourse: [],
-  school_tblschedule: ['PK', 'Length', 'StartTime', 'DayOfWeek', 'FKSubject', 'CalcActualWeeks'],
-  school_tblgroup_group: ['FKGroup', 'FKGroupCon'],
-  school_tblplan_period: ['FKPlan', 'FKPeriod'],
-  school_tblplan_teacher: ['FKPlan', 'FKTeacher'],
-  school_tblplan_group: ['FKPlan', 'FKGroup'],
-  unit_tblperiod_date: ['FKPeriod', 'StartDate', 'EndDate'],
-  school_tblschedule_period: ['FKSchedule', 'FKPeriod'],
-  school_tblschedule_teacher: ['FKSchedule', 'FKTeacher'],
-  school_tblschedule_group: ['FKSchedule', 'FKGroup'],
-  school_tblschedule_room: ['FKSchedule', 'FKRoom']
-};
-var PlanDigital_structure = ['Klass', 'Kurskod', 'Sign', 'Poäng', 'Ht', 'Resurs', 'Vt', 'Summa', 'Period', 'Anteckningar', 'Antal', 'Ämne', 'Kursnamn'];
-var SchoolSoft_structure = ['id', 'group', 'dayid', 'day', 'starttime', 'length', 'teacher', 'subject', 'room', 'period', 'inweek', 'exweek', 'exclass', 'realweeks'];
-var maps = [{
-  structure: SchoolSoft_structure,
-  name: 'SchoolSoft',
-  map: _file.SchoolSoftMap,
-  meta: {
-    structure: ''
-  }
-}, {
-  structure: PlanDigital_structure,
-  name: 'Plan Digital',
-  map: _PlanDigital.PlanDigitalMap,
-  meta: {
-    structure: ''
-  }
-}, {
-  structure: IdunSoft_structure,
-  name: 'IdunSoft',
-  map: _IdunSoft.IdunSoftMap,
-  meta: {
-    structure: ''
-  }
-}, {
-  structure: Skola24_structure,
-  name: 'Skola24',
-  map: _Skola.Skola24Map,
-  meta: {
-    structure: ''
-  }
-}, {
-  structure: RS0_structure,
-  name: 'Royal Schedule Algorithm v0',
-  map: _RS.RSMap,
-  meta: {
-    structure: 'RS/algorithm-0.1.3'
-  }
-}, {
-  structure: RS1_structure,
-  name: 'Royal Schedule Algorithm v1',
-  map: _RS.RSMap.V1,
-  meta: {
-    structure: 'RS/algorithm-1.0.0'
-  }
-}, {
-  structure: RS2_structure,
-  name: 'Royal Schedule Algorithm v2',
-  map: _RS.RSMap.V2,
-  meta: {
-    structure: 'RS/algorithm-2.0.0'
-  }
-}, {
-  structure: core_structure,
-  name: 'Royal Schedule',
-  map: _index.CoreMap,
-  meta: {
-    structure: 'RS/core-1.0.0'
-  }
-}];
-exports.maps = maps;
-//# sourceMappingURL=index.js.map