├── .prettierignore
├── .gitignore
├── public
    ├── logo.png
    └── logo.svg
├── src
    ├── schedule-visualizer
    │   ├── icons
    │   │   ├── OverlapIcon.css
    │   │   ├── style.css
    │   │   ├── ExpandIcon.tsx
    │   │   ├── CollapseIcon.tsx
    │   │   ├── FilterIcon.tsx
    │   │   ├── UWFlowIcon.tsx
    │   │   ├── CartIcon.tsx
    │   │   ├── MaximizeIcon.tsx
    │   │   ├── MinimizeIcon.tsx
    │   │   ├── GitHubIcon.tsx
    │   │   └── OverlapIcon.tsx
    │   ├── components
    │   │   ├── App.css
    │   │   ├── IconLink.css
    │   │   ├── BorderlessButton.css
    │   │   ├── Main.css
    │   │   ├── App.tsx
    │   │   ├── ClassSubCell.css
    │   │   ├── ScheduleActions.css
    │   │   ├── ClassToggleList.css
    │   │   ├── ClassToggle.css
    │   │   ├── Title.tsx
    │   │   ├── Title.css
    │   │   ├── IconLink.tsx
    │   │   ├── BorderlessButton.tsx
    │   │   ├── AsyncContent.tsx
    │   │   ├── UWFlowLink.tsx
    │   │   ├── ClassToggleList.tsx
    │   │   ├── ClassToggle.tsx
    │   │   ├── ScheduleGrid.css
    │   │   ├── ScheduleGrid.tsx
    │   │   ├── ScheduleActions.tsx
    │   │   ├── ColumnCell.tsx
    │   │   ├── Main.tsx
    │   │   ├── ColumnCell.css
    │   │   └── ClassSubCell.tsx
    │   ├── data
    │   │   ├── SupplementaryInfo.ts
    │   │   ├── getQuestParser.ts
    │   │   ├── ScheduleSlot.ts
    │   │   ├── QuestParser.ts
    │   │   ├── ClassTime.ts
    │   │   ├── ClassDate.ts
    │   │   ├── ClassesParser.ts
    │   │   ├── ScheduleParser.ts
    │   │   ├── Class.ts
    │   │   ├── Session.ts
    │   │   ├── ClassSlot.ts
    │   │   ├── CartParser.ts
    │   │   ├── SupplementaryParser.ts
    │   │   └── Schedule.tsx
    │   ├── helpers
    │   │   └── UseConfigBoolean.ts
    │   └── initScheduleVisualizer.tsx
    ├── inject.ts
    ├── helpers
    │   └── getInstructorUWFlow.ts
    ├── main.tsx
    ├── index.css
    └── flow-links
    │   └── initFlowLinks.ts
├── tsconfig.node.json
├── vite.config.ts
├── tsconfig.json
├── .eslintrc.cjs
├── manifest.json
├── README.md
├── package.json
└── LICENSE


/.prettierignore:
--------------------------------------------------------------------------------
1 | dist


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | assets


--------------------------------------------------------------------------------
/public/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BrandonXLF/quest-plus/main/public/logo.png


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/OverlapIcon.css:
--------------------------------------------------------------------------------
1 | .alert {
2 | 	color: var(--alert);
3 | }
4 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/App.css:
--------------------------------------------------------------------------------
1 | #container {
2 | 	display: flex;
3 | 	flex-direction: column;
4 | 	height: 100%;
5 | }
6 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/IconLink.css:
--------------------------------------------------------------------------------
1 | .icon-link {
2 | 	white-space: nowrap;
3 | }
4 | 
5 | .icon-link svg {
6 | 	padding-right: 0.2em;
7 | }
8 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/BorderlessButton.css:
--------------------------------------------------------------------------------
1 | .borderless-btn {
2 | 	border: none;
3 | 	background: none;
4 | 	padding: 0;
5 | 	font-size: inherit;
6 | 	cursor: pointer;
7 | }
8 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/Main.css:
--------------------------------------------------------------------------------
1 | .schedule-planner {
2 | 	display: flex;
3 | 	flex-direction: column;
4 | 	flex: 1;
5 | 	height: 0;
6 | 	padding-bottom: 1em;
7 | 	gap: 0.5em;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/App.tsx:
--------------------------------------------------------------------------------
 1 | import './App.css';
 2 | import Main from './Main';
 3 | 
 4 | export default function App() {
 5 | 	return (
 6 | 		<div id="container">
 7 | 			<Main />
 8 | 		</div>
 9 | 	);
10 | }
11 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/style.css:
--------------------------------------------------------------------------------
 1 | .icon {
 2 | 	height: 1em;
 3 | 	vertical-align: text-bottom;
 4 | 	stroke-linecap: round;
 5 | 	stroke-linejoin: round;
 6 | 	stroke: currentColor;
 7 | 	fill: none;
 8 | 	stroke-width: 2.5;
 9 | }
10 | 


--------------------------------------------------------------------------------
/tsconfig.node.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"compilerOptions": {
 3 | 		"composite": true,
 4 | 		"skipLibCheck": true,
 5 | 		"module": "ESNext",
 6 | 		"moduleResolution": "bundler",
 7 | 		"allowSyntheticDefaultImports": true
 8 | 	},
 9 | 	"include": ["vite.config.ts"]
10 | }
11 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ClassSubCell.css:
--------------------------------------------------------------------------------
 1 | .expanded-content:not(:last-child) {
 2 | 	padding-bottom: 8px;
 3 | }
 4 | 
 5 | .slot-top span[tabIndex] {
 6 | 	cursor: pointer;
 7 | 	user-select: none;
 8 | }
 9 | 
10 | .course-code {
11 | 	font-weight: bold;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ScheduleActions.css:
--------------------------------------------------------------------------------
 1 | .schedule-planner-header {
 2 | 	display: flex;
 3 | 	flex-wrap: wrap;
 4 | 	justify-content: left;
 5 | 	align-items: center;
 6 | 	gap: 0.5em;
 7 | }
 8 | 
 9 | .header-external-links {
10 | 	margin-left: 1em;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ClassToggleList.css:
--------------------------------------------------------------------------------
 1 | .planner-toggles-container {
 2 | 	display: flex;
 3 | 	flex: 1;
 4 | }
 5 | 
 6 | .planner-toggles {
 7 | 	display: flex;
 8 | 	flex-wrap: wrap;
 9 | 	row-gap: 0.5em;
10 | 	column-gap: 1em;
11 | 	width: 0;
12 | 	flex: 1;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ClassToggle.css:
--------------------------------------------------------------------------------
 1 | .schedule-class-toggle {
 2 | 	display: flex;
 3 | 	gap: 0.25em;
 4 | 	align-items: center;
 5 | }
 6 | 
 7 | .schedule-class-toggle input[type='checkbox'] {
 8 | 	margin: 0;
 9 | }
10 | 
11 | .schedule-class-toggle .icon {
12 | 	height: 0.85em;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/Title.tsx:
--------------------------------------------------------------------------------
 1 | import './Title.css';
 2 | 
 3 | export default function Title() {
 4 | 	const src = chrome.runtime.getURL('assets/logo.png');
 5 | 
 6 | 	return (
 7 | 		<hgroup className="top-area">
 8 | 			<img src={src} />
 9 | 			<h2>Quest+ Schedule Planner</h2>
10 | 		</hgroup>
11 | 	);
12 | }
13 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/ExpandIcon.tsx:
--------------------------------------------------------------------------------
 1 | import './style.css';
 2 | 
 3 | export default function ExpandIcon() {
 4 | 	return (
 5 | 		<svg
 6 | 			xmlns="http://www.w3.org/2000/svg"
 7 | 			viewBox="0 0 24 24"
 8 | 			className="icon"
 9 | 		>
10 | 			<title>Expand</title>
11 | 			<path d="M6 8l6 8l6 -8" />
12 | 		</svg>
13 | 	);
14 | }
15 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/CollapseIcon.tsx:
--------------------------------------------------------------------------------
 1 | import './style.css';
 2 | 
 3 | export default function CollapseIcon() {
 4 | 	return (
 5 | 		<svg
 6 | 			xmlns="http://www.w3.org/2000/svg"
 7 | 			viewBox="0 0 24 24"
 8 | 			className="icon"
 9 | 		>
10 | 			<title>Collapse</title>
11 | 			<path d="M6 16l6 -8l6 8" />
12 | 		</svg>
13 | 	);
14 | }
15 | 


--------------------------------------------------------------------------------
/src/inject.ts:
--------------------------------------------------------------------------------
 1 | {
 2 | 	const old_showhide = (
 3 | 		window as unknown as {
 4 | 			showhide: () => void;
 5 | 		}
 6 | 	).showhide;
 7 | 
 8 | 	(
 9 | 		window as unknown as {
10 | 			showhide: () => void;
11 | 		}
12 | 	).showhide = function (...args) {
13 | 		old_showhide(...args);
14 | 		window.dispatchEvent(new Event('quest-plus-page-nav'));
15 | 	};
16 | }
17 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/SupplementaryInfo.ts:
--------------------------------------------------------------------------------
 1 | import ClassDate from './ClassDate';
 2 | 
 3 | export class SupplementaryInfo {
 4 | 	constructor(
 5 | 		public desc: string,
 6 | 		public type: string,
 7 | 		public campus: string,
 8 | 		public enrolled: number,
 9 | 		public capacity: number,
10 | 		public slotDates: {
11 | 			start: ClassDate;
12 | 			end: ClassDate;
13 | 		}[] = []
14 | 	) {}
15 | }
16 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/Title.css:
--------------------------------------------------------------------------------
 1 | .top-area {
 2 | 	display: flex;
 3 | 	justify-content: center;
 4 | 	align-items: center;
 5 | 	gap: 0.5em;
 6 | }
 7 | 
 8 | .top-area img {
 9 | 	height: 2em;
10 | }
11 | 
12 | .top-area h2 {
13 | 	display: inline-block;
14 | 	font-size: 1.5rem;
15 | 	margin: 0;
16 | }
17 | 
18 | @media (min-width: 600px) {
19 | 	.top-area {
20 | 		justify-content: left;
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/getQuestParser.ts:
--------------------------------------------------------------------------------
1 | import CartParser from './CartParser';
2 | import QuestParser from './QuestParser';
3 | import ScheduleParser from './ScheduleParser';
4 | 
5 | export default function getQuestParser(): QuestParser | undefined {
6 | 	if (document.getElementById('SSR_SSENRL_LIST')) return new ScheduleParser();
7 | 	if (document.getElementById('SSR_SSENRL_CART')) return new CartParser();
8 | }
9 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/IconLink.tsx:
--------------------------------------------------------------------------------
 1 | import './IconLink.css';
 2 | 
 3 | export default function IconLink(
 4 | 	attrs: React.AnchorHTMLAttributes<HTMLAnchorElement> & {
 5 | 		icon: React.ReactNode;
 6 | 	}
 7 | ) {
 8 | 	const linkAttrs = { ...attrs, icon: undefined };
 9 | 
10 | 	return (
11 | 		<a {...linkAttrs} className="icon-link">
12 | 			{attrs.icon}
13 | 			{attrs.children}
14 | 		</a>
15 | 	);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/FilterIcon.tsx:
--------------------------------------------------------------------------------
 1 | import './style.css';
 2 | 
 3 | export default function FilterIcon() {
 4 | 	return (
 5 | 		<svg
 6 | 			xmlns="http://www.w3.org/2000/svg"
 7 | 			viewBox="0 0 24 24"
 8 | 			className="icon"
 9 | 		>
10 | 			<title>Filter</title>
11 | 			<path d="M4 4h16v2.172a2 2 0 0 1 -.586 1.414l-4.414 4.414v7l-6 2v-8.5l-4.48 -4.928a2 2 0 0 1 -.52 -1.345v-2.227z" />
12 | 		</svg>
13 | 	);
14 | }
15 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/UWFlowIcon.tsx:
--------------------------------------------------------------------------------
 1 | import './style.css';
 2 | 
 3 | export default function UWFlowIcon() {
 4 | 	return (
 5 | 		<svg
 6 | 			xmlns="http://www.w3.org/2000/svg"
 7 | 			viewBox="0 0 24 24"
 8 | 			className="icon"
 9 | 		>
10 | 			<title>UW Flow</title>
11 | 			<circle cx="12" cy="12" r="3" fill="currentColor" />
12 | 			<path d="M12 12m-9 0a9 9 0 1 0 18 0a9 9 0 1 0 -18 0" />
13 | 		</svg>
14 | 	);
15 | }
16 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/BorderlessButton.tsx:
--------------------------------------------------------------------------------
 1 | import './BorderlessButton.css';
 2 | 
 3 | export default function BorderlessButton(
 4 | 	props: Readonly<React.ButtonHTMLAttributes<HTMLButtonElement>>
 5 | ) {
 6 | 	return (
 7 | 		<button
 8 | 			{...props}
 9 | 			className={`borderless-btn ${props.className ?? ''}`}
10 | 			onClick={e => {
11 | 				e.preventDefault();
12 | 				props.onClick?.(e);
13 | 			}}
14 | 		/>
15 | 	);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/CartIcon.tsx:
--------------------------------------------------------------------------------
 1 | import './style.css';
 2 | 
 3 | export default function CartIcon() {
 4 | 	return (
 5 | 		<svg
 6 | 			xmlns="http://www.w3.org/2000/svg"
 7 | 			viewBox="0 0 24 24"
 8 | 			className="icon"
 9 | 		>
10 | 			<title>Cart</title>
11 | 			<path d="M6 19m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
12 | 			<path d="M17 19m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0" />
13 | 			<path d="M17 17h-11v-14h-2" />
14 | 			<path d="M6 5l14 1l-1 7h-13" />
15 | 		</svg>
16 | 	);
17 | }
18 | 


--------------------------------------------------------------------------------
/vite.config.ts:
--------------------------------------------------------------------------------
 1 | import { defineConfig } from 'vite';
 2 | import react from '@vitejs/plugin-react-swc';
 3 | 
 4 | // https://vitejs.dev/config/
 5 | export default defineConfig({
 6 | 	base: './',
 7 | 	plugins: [react()],
 8 | 	build: {
 9 | 		rollupOptions: {
10 | 			input: {
11 | 				content: 'src/main.tsx',
12 | 				inject: 'src/inject.ts'
13 | 			},
14 | 			output: {
15 | 				dir: 'assets',
16 | 				entryFileNames: '[name].js',
17 | 				assetFileNames: '[name].css'
18 | 			}
19 | 		}
20 | 	}
21 | });
22 | 


--------------------------------------------------------------------------------
/src/helpers/getInstructorUWFlow.ts:
--------------------------------------------------------------------------------
 1 | function normalizeName(name: string) {
 2 | 	return name
 3 | 		.toLowerCase()
 4 | 		.replace(/ /g, '_')
 5 | 		.replace(/[^a-z_]/g, '');
 6 | }
 7 | 
 8 | export default function getInstructorUWFlow(name: string) {
 9 | 	if (name === 'Staff' || name === 'To be Announced') return;
10 | 
11 | 	const shortForm = name[1] === '.';
12 | 
13 | 	return (
14 | 		(shortForm ? '/explore?q=' : '/professor/') +
15 | 		encodeURIComponent(shortForm ? name : normalizeName(name))
16 | 	);
17 | }
18 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/MaximizeIcon.tsx:
--------------------------------------------------------------------------------
 1 | export default function MaximizeIcon() {
 2 | 	return (
 3 | 		<svg
 4 | 			xmlns="http://www.w3.org/2000/svg"
 5 | 			viewBox="0 0 24 24"
 6 | 			className="icon"
 7 | 		>
 8 | 			<title>Maximize</title>
 9 | 			<path d="M16 4l4 0l0 4" />
10 | 			<path d="M14 10l6 -6" />
11 | 			<path d="M8 20l-4 0l0 -4" />
12 | 			<path d="M4 20l6 -6" />
13 | 			<path d="M16 20l4 0l0 -4" />
14 | 			<path d="M14 14l6 6" />
15 | 			<path d="M8 4l-4 0l0 4" />
16 | 			<path d="M4 4l6 6" />
17 | 		</svg>
18 | 	);
19 | }
20 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/MinimizeIcon.tsx:
--------------------------------------------------------------------------------
 1 | export default function MinimizeIcon() {
 2 | 	return (
 3 | 		<svg
 4 | 			xmlns="http://www.w3.org/2000/svg"
 5 | 			viewBox="0 0 24 24"
 6 | 			className="icon"
 7 | 		>
 8 | 			<title>Minimize</title>
 9 | 			<path d="M5 9l4 0l0 -4" />
10 | 			<path d="M3 3l6 6" />
11 | 			<path d="M5 15l4 0l0 4" />
12 | 			<path d="M3 21l6 -6" />
13 | 			<path d="M19 9l-4 0l0 -4" />
14 | 			<path d="M15 9l6 -6" />
15 | 			<path d="M19 15l-4 0l0 4" />
16 | 			<path d="M15 15l6 6" />
17 | 		</svg>
18 | 	);
19 | }
20 | 


--------------------------------------------------------------------------------
/src/main.tsx:
--------------------------------------------------------------------------------
 1 | import initFlowLinks from './flow-links/initFlowLinks.ts';
 2 | import initScheduleVisualizer from './schedule-visualizer/initScheduleVisualizer.tsx';
 3 | import './index.css';
 4 | 
 5 | function onPageLoaded() {
 6 | 	initFlowLinks();
 7 | 	initScheduleVisualizer();
 8 | }
 9 | 
10 | onPageLoaded();
11 | window.addEventListener('quest-plus-page-nav', () => onPageLoaded());
12 | 
13 | const s = document.createElement('script');
14 | s.defer = true;
15 | s.src = chrome.runtime.getURL('assets/inject.js');
16 | 
17 | document.head.append(s);
18 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/ScheduleSlot.ts:
--------------------------------------------------------------------------------
 1 | import { ReactNode } from 'react';
 2 | import ClassSlot from './ClassSlot';
 3 | 
 4 | export enum SlotType {
 5 | 	Class = 'class',
 6 | 	Time = 'time',
 7 | 	Gap = 'gap',
 8 | 	Blank = 'blank'
 9 | }
10 | 
11 | type ScheduleSlot = {
12 | 	start: number;
13 | 	end: number;
14 | } & (
15 | 	| {
16 | 			type: Exclude<SlotType, SlotType.Class>;
17 | 			content: ReactNode;
18 | 	  }
19 | 	| {
20 | 			type: SlotType.Class;
21 | 			classSlots: ClassSlot[];
22 | 	  }
23 | );
24 | 
25 | export default ScheduleSlot;
26 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/AsyncContent.tsx:
--------------------------------------------------------------------------------
 1 | import { ReactElement, useEffect, useState } from 'react';
 2 | 
 3 | export default function AsyncContent({
 4 | 	load,
 5 | 	deps = [],
 6 | 	indicator = '...'
 7 | }: {
 8 | 	load: () => Promise<ReactElement | string>;
 9 | 	deps?: React.DependencyList;
10 | 	indicator?: string;
11 | }) {
12 | 	const [output, setOutput] = useState<ReactElement | string>();
13 | 
14 | 	useEffect(() => {
15 | 		(async () => setOutput(await load()))();
16 | 	}, [load, ...deps]);
17 | 
18 | 	return output ?? indicator;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/UWFlowLink.tsx:
--------------------------------------------------------------------------------
 1 | import UWFlowIcon from '../icons/UWFlowIcon';
 2 | import IconLink from './IconLink';
 3 | 
 4 | export default function UWFlowLink({
 5 | 	path,
 6 | 	children
 7 | }: Readonly<{
 8 | 	path?: string;
 9 | 	children?: React.ReactNode;
10 | }>) {
11 | 	if (!children) return;
12 | 
13 | 	return (
14 | 		<IconLink
15 | 			target="quest-plus-uw-flow"
16 | 			href={`https://uwflow.com${path}`}
17 | 			onClick={e => e.stopPropagation()}
18 | 			icon={<UWFlowIcon />}
19 | 		>
20 | 			{children}
21 | 		</IconLink>
22 | 	);
23 | }
24 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/GitHubIcon.tsx:
--------------------------------------------------------------------------------
 1 | export default function GitHubIcon() {
 2 | 	return (
 3 | 		<svg
 4 | 			xmlns="http://www.w3.org/2000/svg"
 5 | 			viewBox="0 0 24 24"
 6 | 			className="icon"
 7 | 		>
 8 | 			<title>GitHub</title>
 9 | 			<path stroke="none" d="M0 0h24v24H0z" fill="none" />
10 | 			<path d="M9 19c-4.3 1.4 -4.3 -2.5 -6 -3m12 5v-3.5c0 -1 .1 -1.4 -.5 -2c2.8 -.3 5.5 -1.4 5.5 -6a4.6 4.6 0 0 0 -1.3 -3.2a4.2 4.2 0 0 0 -.1 -3.2s-1.1 -.3 -3.5 1.3a12.3 12.3 0 0 0 -6.2 0c-2.4 -1.6 -3.5 -1.3 -3.5 -1.3a4.2 4.2 0 0 0 -.1 3.2a4.6 4.6 0 0 0 -1.3 3.2c0 4.6 2.7 5.7 5.5 6c-.6 .6 -.6 1.2 -.5 2v3.5" />
11 | 		</svg>
12 | 	);
13 | }
14 | 


--------------------------------------------------------------------------------
/src/index.css:
--------------------------------------------------------------------------------
 1 | .schedule-planner {
 2 | 	--theme: #f5bd00;
 3 | 	--theme-light: #ffe799;
 4 | 	--color: #000;
 5 | 	--alert: #800000;
 6 | 	--lighter: #333;
 7 | 	--link: rgb(0, 82, 204);
 8 | 	--bg-darker: #ebebeb;
 9 | 	--bg-blue: #e5f0fa;
10 | 	--bg-purple: #f4e2fd;
11 | 	--bg-green: #e4fbe4;
12 | 	--bg-orange: #fcf3e3;
13 | 	--bg-yellow: #fbfbe4;
14 | 	--border-color: #666;
15 | 	--semi-transparent: #fffffff2;
16 | }
17 | 
18 | .schedule-planner a,
19 | .schedule-planner a:visited {
20 | 	color: var(--link);
21 | }
22 | 
23 | .schedule-planner * {
24 | 	box-sizing: border-box;
25 | }
26 | 
27 | #ACE_width {
28 | 	width: 100% !important;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/QuestParser.ts:
--------------------------------------------------------------------------------
 1 | import Class from './Class';
 2 | 
 3 | export default abstract class QuestParser {
 4 | 	protected getElementContents(el?: HTMLElement | null) {
 5 | 		if (!el) return '';
 6 | 
 7 | 		const text =
 8 | 			'questPlusInnerText' in el.dataset
 9 | 				? el.dataset.questPlusInnerText!
10 | 				: el.innerText;
11 | 
12 | 		return text.trim().replace(/ +/g, ' ');
13 | 	}
14 | 
15 | 	protected getChildContents(row: HTMLTableRowElement, idPart: string) {
16 | 		return this.getElementContents(
17 | 			row.querySelector<HTMLElement>(`[id*="${idPart}"]`)
18 | 		);
19 | 	}
20 | 
21 | 	public abstract parse(): Class[];
22 | }
23 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/ClassTime.ts:
--------------------------------------------------------------------------------
 1 | export default class ClassTime {
 2 | 	public hours;
 3 | 	public minutes;
 4 | 	public index;
 5 | 
 6 | 	constructor(
 7 | 		hourStr: string,
 8 | 		minStr: string,
 9 | 		public period: 'AM' | 'PM'
10 | 	) {
11 | 		this.hours = parseInt(hourStr);
12 | 		this.minutes = parseInt(minStr);
13 | 		this.index =
14 | 			(period === 'PM' ? (this.hours % 12) + 12 : this.hours % 12) * 60 +
15 | 			this.minutes;
16 | 	}
17 | 
18 | 	valueOf() {
19 | 		return this.index;
20 | 	}
21 | 
22 | 	toString() {
23 | 		return `${this.hours % 12 || 12}:${this.minutes
24 | 			.toString()
25 | 			.padStart(2, '0')} ${this.period}`;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/icons/OverlapIcon.tsx:
--------------------------------------------------------------------------------
 1 | import './style.css';
 2 | import './OverlapIcon.css';
 3 | 
 4 | export default function OverlapIcon() {
 5 | 	return (
 6 | 		<svg
 7 | 			xmlns="http://www.w3.org/2000/svg"
 8 | 			viewBox="0 0 24 24"
 9 | 			className="icon alert"
10 | 		>
11 | 			<title>Overlap</title>
12 | 			<path
13 | 				d="M4 5a1 1 0 0 1 .3 -.714a6 6 0 0 1 8.213 -.176l.351 .328a4 4 0 0 0 5.272 0l.249 -.227c.61 -.483 1.527 -.097 1.61 .676l.005 .113v9a1 1 0 0 1 -.3 .714a6 6 0 0 1 -8.213 .176l-.351 -.328a4 4 0 0 0 -5.136 -.114v6.552a1 1 0 0 1 -1.993 .117l-.007 -.117v-16z"
14 | 				strokeWidth="0"
15 | 				fill="currentColor"
16 | 			/>
17 | 		</svg>
18 | 	);
19 | }
20 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"compilerOptions": {
 3 | 		"target": "ES2022",
 4 | 		"useDefineForClassFields": true,
 5 | 		"lib": ["ES2022", "DOM", "DOM.Iterable"],
 6 | 		"module": "ESNext",
 7 | 		"skipLibCheck": true,
 8 | 
 9 | 		/* Bundler mode */
10 | 		"moduleResolution": "bundler",
11 | 		"allowImportingTsExtensions": true,
12 | 		"resolveJsonModule": true,
13 | 		"isolatedModules": true,
14 | 		"noEmit": true,
15 | 		"jsx": "react-jsx",
16 | 
17 | 		/* Linting */
18 | 		"strict": true,
19 | 		"noUnusedLocals": true,
20 | 		"noUnusedParameters": true,
21 | 		"noFallthroughCasesInSwitch": true
22 | 	},
23 | 	"include": ["src"],
24 | 	"references": [{ "path": "./tsconfig.node.json" }]
25 | }
26 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/helpers/UseConfigBoolean.ts:
--------------------------------------------------------------------------------
 1 | import { useEffect, useState } from 'react';
 2 | 
 3 | export default function useConfigBoolean(name: string, initial: boolean) {
 4 | 	const [isEnabled, setIsEnabled] = useState<boolean>(initial);
 5 | 
 6 | 	useEffect(() => {
 7 | 		(async () => {
 8 | 			const state = (await chrome.storage.local.get(name))[name] as
 9 | 				| boolean
10 | 				| undefined;
11 | 
12 | 			if (state === undefined) return;
13 | 
14 | 			setIsEnabled(state);
15 | 		})();
16 | 	}, [name]);
17 | 
18 | 	useEffect(() => {
19 | 		chrome.storage.local.set({
20 | 			[name]: isEnabled
21 | 		});
22 | 	}, [name, isEnabled]);
23 | 
24 | 	return [isEnabled, setIsEnabled] as const;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/ClassDate.ts:
--------------------------------------------------------------------------------
 1 | export default class ClassDate {
 2 | 	public month;
 3 | 	public day;
 4 | 
 5 | 	constructor(dateStr: string, end = false) {
 6 | 		if (!dateStr) {
 7 | 			this.month = end ? Infinity : -Infinity;
 8 | 			this.day = 0;
 9 | 
10 | 			return;
11 | 		}
12 | 
13 | 		const [monthStr, dayStr] = dateStr.split('/');
14 | 
15 | 		this.month = parseInt(monthStr);
16 | 		this.day = parseInt(dayStr);
17 | 	}
18 | 
19 | 	isDefined() {
20 | 		return this.month !== Infinity && this.month !== -Infinity;
21 | 	}
22 | 
23 | 	valueOf() {
24 | 		return this.month * 100 + this.day;
25 | 	}
26 | 
27 | 	toString() {
28 | 		return `${this.month}/${this.day.toString().padStart(2, '0')}`;
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/initScheduleVisualizer.tsx:
--------------------------------------------------------------------------------
 1 | import React from 'react';
 2 | import ReactDOM from 'react-dom/client';
 3 | import App from './components/App';
 4 | 
 5 | export default function initScheduleVisualizer() {
 6 | 	if (document.getElementById('schedule-planner-root')) return;
 7 | 
 8 | 	const cnt = document.querySelector(
 9 | 		'[id*="STDNT_ENRL_SSV2"], [id*="DERIVED_REGFRM1_GROUP6"]'
10 | 	);
11 | 
12 | 	if (!cnt) return;
13 | 
14 | 	const root = document.createElement('div');
15 | 	root.id = 'schedule-planner-root';
16 | 
17 | 	cnt?.prepend(root);
18 | 	cnt.closest('td')!.style.width = '100%';
19 | 
20 | 	ReactDOM.createRoot(root).render(
21 | 		<React.StrictMode>
22 | 			<App />
23 | 		</React.StrictMode>
24 | 	);
25 | }
26 | 


--------------------------------------------------------------------------------
/public/logo.svg:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <svg version="1.1" viewBox="0 0 131.88 131.88" xmlns="http://www.w3.org/2000/svg">
3 |    <g transform="translate(-12.283 -103.26)">
4 |       <path d="m41.828 172.86s-3.0625 11.388-15.153 9.1222c-9.867-1.8494-12.67-8.3696-11.586-15.176 1.3833-8.6841 4.3214-13.259 11.586-15.899 8.8538-3.2177 12.131-1.4398 18.489 2.1226 5.0582 2.8341 8.8885 5.9656 9.0106 14.652 0.37556 26.724 6.9539 38.342 12.925 38.5 6.0259 0.15908 13.133-2.75 12.583-22.55s-10.286-30.567 4.4667-31.625c15.543-1.1149 6.2502 14.528 7.3502 32.678 0.43876 7.2396 2.4561 21.834 10.922 22.232 9.3318 0.43944 12.427-27.664 8.7046-48.269-2.0638-11.423 10.041-23.442 33.011-23.258" fill="none" stroke="#f5bd00" stroke-width="8"/>
5 |    </g>
6 | </svg>
7 | 


--------------------------------------------------------------------------------
/.eslintrc.cjs:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	root: true,
 3 | 	env: { browser: true, es2020: true },
 4 | 	extends: [
 5 | 		'eslint:recommended',
 6 | 		'plugin:@typescript-eslint/recommended',
 7 | 		'plugin:react-hooks/recommended',
 8 | 		'plugin:react/recommended',
 9 | 		'plugin:react/jsx-runtime',
10 | 		'prettier'
11 | 	],
12 | 	ignorePatterns: ['dist', '.eslintrc.cjs'],
13 | 	parser: '@typescript-eslint/parser',
14 | 	plugins: ['react-refresh'],
15 | 	rules: {
16 | 		'react-refresh/only-export-components': [
17 | 			'warn',
18 | 			{ allowConstantExport: true }
19 | 		],
20 | 		'react/self-closing-comp': [
21 | 			'error',
22 | 			{
23 | 				component: true,
24 | 				html: true
25 | 			}
26 | 		],
27 | 		indent: ['warn', 'tab'],
28 | 		quotes: ['warn', 'single']
29 | 	},
30 | 	settings: {
31 | 		react: {
32 | 			version: 'detect'
33 | 		}
34 | 	}
35 | };
36 | 


--------------------------------------------------------------------------------
/manifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "Quest+",
 3 | 	"version": "1.0.0",
 4 | 	"description": "Adds enhancements to the University of Waterloo's Quest website like links to UW Flow and a schedule visualizer.",
 5 | 	"permissions": ["activeTab", "scripting", "storage"],
 6 | 	"host_permissions": ["https://quest.pecs.uwaterloo.ca/"],
 7 | 	"icons": {
 8 | 		"128": "assets/logo.png"
 9 | 	},
10 | 	"content_scripts": [
11 | 		{
12 | 			"matches": ["https://quest.pecs.uwaterloo.ca/*"],
13 | 			"js": ["assets/content.js"],
14 | 			"css": ["assets/content.css"],
15 | 			"all_frames": true,
16 | 			"run_at": "document_end"
17 | 		}
18 | 	],
19 | 	"web_accessible_resources": [
20 | 		{
21 | 			"matches": ["https://quest.pecs.uwaterloo.ca/*"],
22 | 			"resources": ["assets/logo.png", "assets/logo.svg", "assets/inject.js"]
23 | 		}
24 | 	],
25 | 	"manifest_version": 3
26 | }
27 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Quest+
 2 | 
 3 | **Quest+** is a Chrome extension that enhances the University of Waterloo's Quest platform with a persistent schedule visualization and links to instructor and course reviews. 
 4 | 
 5 | ## Features
 6 | 
 7 | ### Schedule Visualization
 8 | * Persistent and time-accurate visualization of your course schedule
 9 | * Added to all pages (my schedule, shopping card, and class modification pages)
10 | 
11 | ### Links to Reviews
12 | * UW Flow and Rate My Professors links are added next to instructor's names
13 | * Courses names are linked to their page on UW Flow
14 | 
15 | ## Building
16 | Quest+ is built using Node.js, so make sure it is installed and set up properly. With Node.js installed, run `npm install` to install dependencies and run `npm run build` to build release versions of the code. Run `npm run watch` to automatically build when files are changed.
17 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ClassToggleList.tsx:
--------------------------------------------------------------------------------
 1 | import './ClassToggleList.css';
 2 | import Class from '../data/Class';
 3 | import ClassToggle from './ClassToggle';
 4 | 
 5 | export default function ClassToggleList({
 6 | 	classes,
 7 | 	hiddenClasses,
 8 | 	onHiddenClassesChanged
 9 | }: Readonly<{
10 | 	classes: Class[];
11 | 	hiddenClasses: Record<string, boolean>;
12 | 	onHiddenClassesChanged: (changes: Record<string, boolean>) => void;
13 | }>) {
14 | 	return (
15 | 		<div className="planner-toggles-container">
16 | 			<div className="planner-toggles">
17 | 				{classes.map(classInfo => (
18 | 					<ClassToggle
19 | 						key={classInfo.identifier}
20 | 						classInfo={classInfo}
21 | 						hidden={hiddenClasses[classInfo.identifier] === true}
22 | 						onHiddenChanged={hidden =>
23 | 							onHiddenClassesChanged({
24 | 								[classInfo.identifier]: hidden
25 | 							})
26 | 						}
27 | 					/>
28 | 				))}
29 | 			</div>
30 | 		</div>
31 | 	);
32 | }
33 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ClassToggle.tsx:
--------------------------------------------------------------------------------
 1 | import './ClassToggle.css';
 2 | import AsyncContent from './AsyncContent';
 3 | import Class from '../data/Class';
 4 | import CartIcon from '../icons/CartIcon';
 5 | 
 6 | export default function ClassToggle({
 7 | 	hidden,
 8 | 	classInfo,
 9 | 	onHiddenChanged
10 | }: Readonly<{
11 | 	hidden: boolean;
12 | 	classInfo: Class;
13 | 	onHiddenChanged: (hidden: boolean) => void;
14 | }>) {
15 | 	return (
16 | 		<div>
17 | 			<label className="schedule-class-toggle">
18 | 				<input
19 | 					type="checkbox"
20 | 					checked={!hidden}
21 | 					onInput={() => onHiddenChanged(!hidden)}
22 | 				/>
23 | 				{classInfo.cart && (
24 | 					<>
25 | 						<CartIcon />{' '}
26 | 					</>
27 | 				)}
28 | 				<span>{classInfo.identifier}</span>
29 | 				<span>
30 | 					<AsyncContent
31 | 						load={async () => ` ${await classInfo.getType()}`}
32 | 						deps={[classInfo]}
33 | 					/>
34 | 				</span>
35 | 			</label>
36 | 		</div>
37 | 	);
38 | }
39 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "quest-plus",
 3 | 	"private": true,
 4 | 	"version": "1.0.0",
 5 | 	"type": "module",
 6 | 	"scripts": {
 7 | 		"build": "tsc && vite build",
 8 | 		"lint": "prettier . --use-tabs --single-quote --write --arrow-parens avoid --trailing-comma none && eslint . --fix --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
 9 | 		"preview": "vite preview",
10 | 		"watch": "vite build --watch"
11 | 	},
12 | 	"dependencies": {
13 | 		"react": "^18.2.0",
14 | 		"react-dom": "^18.2.0"
15 | 	},
16 | 	"devDependencies": {
17 | 		"@types/chrome": "^0.0.258",
18 | 		"@types/react": "^18.2.15",
19 | 		"@types/react-dom": "^18.2.7",
20 | 		"@typescript-eslint/eslint-plugin": "^6.0.0",
21 | 		"@typescript-eslint/parser": "^6.0.0",
22 | 		"@vitejs/plugin-react-swc": "^3.3.2",
23 | 		"eslint": "^8.47.0",
24 | 		"eslint-config-prettier": "^9.0.0",
25 | 		"eslint-plugin-react": "^7.33.1",
26 | 		"eslint-plugin-react-hooks": "^4.6.0",
27 | 		"eslint-plugin-react-refresh": "^0.4.3",
28 | 		"prettier": "^3.0.0",
29 | 		"typescript": "^5.0.2",
30 | 		"vite": "^5.0.2"
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/ClassesParser.ts:
--------------------------------------------------------------------------------
 1 | export default abstract class UWParser {
 2 | 	private domParser = new DOMParser();
 3 | 
 4 | 	protected async fetchTableRows(
 5 | 		path: string,
 6 | 		tableNumbers: number
 7 | 	): Promise<HTMLTableRowElement[]>;
 8 | 	protected async fetchTableRows(
 9 | 		path: string,
10 | 		tableNumbers: number[]
11 | 	): Promise<HTMLTableRowElement[][]>;
12 | 	protected async fetchTableRows(
13 | 		path: string,
14 | 		tableNumbers: number | number[]
15 | 	) {
16 | 		const res = await fetch(
17 | 			`https://www.brandonfowler.me/wisp/uw-classes/?path=${encodeURIComponent(
18 | 				path
19 | 			)}`
20 | 		);
21 | 
22 | 		if (!res.ok) throw new TypeError(res.statusText);
23 | 
24 | 		if (!Array.isArray(tableNumbers)) tableNumbers = [tableNumbers];
25 | 
26 | 		const doc = this.domParser.parseFromString(await res.text(), 'text/html');
27 | 		const tableCollection = doc.getElementsByTagName('table');
28 | 
29 | 		const tables = tableNumbers.map(tableNumber => {
30 | 			const rows = tableCollection[tableNumber]?.rows;
31 | 
32 | 			return rows ? [...rows] : [];
33 | 		});
34 | 
35 | 		return tables.length === 1 ? tables[0] : tables;
36 | 	}
37 | 
38 | 	protected getCellContents(row: HTMLTableRowElement, index: number) {
39 | 		return row.cells[index]?.innerText.trim().replace(/ +/g, ' ') ?? '';
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/ScheduleParser.ts:
--------------------------------------------------------------------------------
 1 | import Class from './Class';
 2 | import ClassSlot from './ClassSlot';
 3 | import QuestParser from './QuestParser';
 4 | 
 5 | export default class ScheduleParser extends QuestParser {
 6 | 	static readonly DIVIDER_PARSER = /^([A-Z]+) (\d+[A-Z]?) - ([A-Za-z ]+)/;
 7 | 
 8 | 	parseDivider(divider: string) {
 9 | 		const res = ScheduleParser.DIVIDER_PARSER.exec(divider);
10 | 
11 | 		if (!res) return ['UKN', 'UKN', 'UKN'] as const;
12 | 
13 | 		res.splice(0, 1);
14 | 
15 | 		return res as string[] as [string, string, string];
16 | 	}
17 | 
18 | 	parse() {
19 | 		const rows = [
20 | 			...document.querySelectorAll<HTMLTableRowElement>(
21 | 				'[id^="trCLASS_MTG_VW$"]'
22 | 			)
23 | 		];
24 | 
25 | 		return rows.map(row => {
26 | 			const divider = this.parseDivider(
27 | 				this.getElementContents(
28 | 					row
29 | 						.closest('[id*="win0divDERIVED_REGFRM1_DESCR20"]')
30 | 						?.querySelector<HTMLDivElement>('.PAGROUPDIVIDER')
31 | 				)
32 | 			);
33 | 
34 | 			// TODO: Use start/end dates?
35 | 			const classInfo = new Class(
36 | 				divider[0],
37 | 				divider[1],
38 | 				this.getChildContents(row, 'MTG_SECTION'),
39 | 				this.getChildContents(row, 'CLASS_NBR'),
40 | 				this.getChildContents(row, 'MTG_COMP'),
41 | 				divider[2],
42 | 				this.getChildContents(row, 'INSTR_LONG')
43 | 			);
44 | 
45 | 			const slot = ClassSlot.fromString(
46 | 				classInfo,
47 | 				this.getChildContents(row, 'SCHED'),
48 | 				this.getChildContents(row, 'LOC')
49 | 			);
50 | 
51 | 			if (slot) classInfo.slots.push(slot);
52 | 
53 | 			return classInfo;
54 | 		});
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/Class.ts:
--------------------------------------------------------------------------------
 1 | import ClassSlot from './ClassSlot';
 2 | import SupplementaryParser from './SupplementaryParser';
 3 | import { SupplementaryInfo } from './SupplementaryInfo';
 4 | 
 5 | export default class Class {
 6 | 	readonly supplementaryInfo: Promise<SupplementaryInfo>;
 7 | 	readonly instructors: string[];
 8 | 
 9 | 	constructor(
10 | 		public subject: string,
11 | 		public courseNumber: string,
12 | 		public section: string,
13 | 		public classNumber: string,
14 | 		public type: string,
15 | 		public desc: string,
16 | 		public instructorString: string,
17 | 		public cart: boolean = false,
18 | 		public slots: ClassSlot[] = []
19 | 	) {
20 | 		this.supplementaryInfo = SupplementaryParser.getSupplementaryInfo(
21 | 			'1241',
22 | 			subject,
23 | 			courseNumber,
24 | 			classNumber
25 | 		);
26 | 
27 | 		this.instructors = this.instructorString
28 | 			.split(',')
29 | 			.map(rawName => rawName.trim());
30 | 	}
31 | 
32 | 	public get code() {
33 | 		return `${this.subject} ${this.courseNumber}`;
34 | 	}
35 | 
36 | 	public get identifier() {
37 | 		return `${this.subject} ${this.courseNumber} ${this.section}`;
38 | 	}
39 | 
40 | 	async getEnrolledString() {
41 | 		const info = await this.supplementaryInfo;
42 | 
43 | 		return `${info.enrolled}/${info.capacity}`;
44 | 	}
45 | 
46 | 	async getType() {
47 | 		if (this.type) return this.type;
48 | 
49 | 		const info = await this.supplementaryInfo;
50 | 
51 | 		return info.type;
52 | 	}
53 | 
54 | 	async getDatesForSlot(slot: ClassSlot) {
55 | 		const index = this.slots.indexOf(slot);
56 | 
57 | 		return (await this.supplementaryInfo).slotDates[index];
58 | 	}
59 | }
60 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/Session.ts:
--------------------------------------------------------------------------------
 1 | export default class Session {
 2 | 	static semesters = [
 3 | 		{
 4 | 			name: 'Winter',
 5 | 			start: 1
 6 | 		},
 7 | 		{
 8 | 			name: 'Spring',
 9 | 			start: 5
10 | 		},
11 | 		{
12 | 			name: 'Fall',
13 | 			start: 9
14 | 		}
15 | 	];
16 | 
17 | 	static getCurrent() {
18 | 		const now = new Date();
19 | 		const currentMonth = now.getMonth() + 1;
20 | 
21 | 		let activeYear = now.getFullYear();
22 | 		let activeSemester = this.semesters.findIndex(
23 | 			semester => currentMonth <= semester.start
24 | 		);
25 | 
26 | 		if (activeSemester == -1) {
27 | 			activeYear++;
28 | 			activeSemester = 0;
29 | 		}
30 | 
31 | 		return new Session(activeYear, activeSemester);
32 | 	}
33 | 
34 | 	constructor(
35 | 		public year: number,
36 | 		public semester: number
37 | 	) {}
38 | 
39 | 	get code() {
40 | 		return `${this.year - 1900}${Session.semesters[this.semester].start}`;
41 | 	}
42 | 
43 | 	get name() {
44 | 		return `${Session.semesters[this.semester].name} ${this.year}`;
45 | 	}
46 | 
47 | 	get next() {
48 | 		let nextYear = this.year;
49 | 		let nextSemester = this.semester + 1;
50 | 
51 | 		if (nextSemester == Session.semesters.length) {
52 | 			nextYear++;
53 | 			nextSemester = 0;
54 | 		}
55 | 
56 | 		return new Session(nextYear, nextSemester);
57 | 	}
58 | 
59 | 	get prev() {
60 | 		let nextYear = this.year;
61 | 		let nextSemester = this.semester - 1;
62 | 
63 | 		if (nextSemester == -1) {
64 | 			nextYear--;
65 | 			nextSemester = Session.semesters.length - 1;
66 | 		}
67 | 
68 | 		return new Session(nextYear, nextSemester);
69 | 	}
70 | 
71 | 	toString() {
72 | 		return this.code;
73 | 	}
74 | }
75 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ScheduleGrid.css:
--------------------------------------------------------------------------------
 1 | .schedule-container {
 2 | 	flex: 1;
 3 | 	height: 0;
 4 | 	position: relative;
 5 | 	display: flex;
 6 | 	flex-direction: column;
 7 | }
 8 | 
 9 | .schedule {
10 | 	overscroll-behavior: none;
11 | 	background: center / cover
12 | 		url('chrome-extension://__MSG_@@extension_id__/assets/logo.svg');
13 | }
14 | 
15 | @media not print {
16 | 	.schedule {
17 | 		overflow: auto;
18 | 	}
19 | }
20 | 
21 | .columns {
22 | 	display: grid;
23 | 	grid-template-columns: auto repeat(5, 1fr);
24 | 	grid-template-rows: min-content auto;
25 | 	min-width: 50em;
26 | 	font-size: 11px;
27 | 	background-color: var(--semi-transparent);
28 | }
29 | 
30 | .mini .columns {
31 | 	grid-template-columns: repeat(5, 1fr);
32 | 	column-gap: 8px;
33 | }
34 | 
35 | .header,
36 | .column {
37 | 	border-color: var(--border-color);
38 | 	border-style: solid;
39 | }
40 | 
41 | .header {
42 | 	position: sticky;
43 | 	top: 0;
44 | 	background: var(--bg);
45 | 	text-align: center;
46 | 	border-width: 0 0 1px 0;
47 | 	padding-bottom: 4px;
48 | 	font-size: 125%;
49 | }
50 | 
51 | .scrolled-y .header {
52 | 	z-index: 3;
53 | }
54 | 
55 | .mini .header:first-child {
56 | 	display: none;
57 | }
58 | 
59 | .mini .header-empty-col {
60 | 	border-width: 0;
61 | }
62 | 
63 | .column {
64 | 	display: flex;
65 | 	flex-direction: column;
66 | 	min-width: 3em;
67 | 	width: 100%;
68 | 	border-width: 0;
69 | }
70 | 
71 | .schedule:not(.mini) .column {
72 | 	border-right-width: 1px;
73 | }
74 | 
75 | .time-column {
76 | 	position: sticky;
77 | 	left: 0;
78 | 	background: var(--theme-light);
79 | 	border-left-width: 1px;
80 | }
81 | 
82 | .scrolled-x .time-column {
83 | 	z-index: 2;
84 | }
85 | 
86 | .mini .time-column {
87 | 	display: none;
88 | }
89 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ScheduleGrid.tsx:
--------------------------------------------------------------------------------
 1 | import Class from '../data/Class';
 2 | import './ScheduleGrid.css';
 3 | import ColumnCell from './ColumnCell';
 4 | import { useMemo } from 'react';
 5 | import Schedule from '../data/Schedule';
 6 | 
 7 | function gridOnScroll(e: React.UIEvent) {
 8 | 	const el = e.target as HTMLDivElement;
 9 | 
10 | 	el.classList.toggle('scrolled-x', !!el.scrollLeft);
11 | 	el.classList.toggle('scrolled-y', !!el.scrollTop);
12 | }
13 | 
14 | export default function ScheduleGrid({
15 | 	classes,
16 | 	isMini
17 | }: Readonly<{
18 | 	classes: Class[];
19 | 	isMini?: boolean;
20 | }>) {
21 | 	const [columns, timeColumn] = useMemo(() => {
22 | 		const schedule = new Schedule(classes);
23 | 
24 | 		return [schedule.prepareColumns(), schedule.prepareTimeColumn()];
25 | 	}, [classes]);
26 | 
27 | 	return (
28 | 		<div className="schedule-container">
29 | 			<div
30 | 				className={`schedule${isMini ? ' mini' : ''}`}
31 | 				onScroll={gridOnScroll}
32 | 			>
33 | 				<div className="columns">
34 | 					<div className="header" />
35 | 					{Schedule.days.map((day, i) => (
36 | 						<div
37 | 							key={day}
38 | 							className={`header${
39 | 								columns[i].length > 1 ? '' : ' header-empty-col'
40 | 							}`}
41 | 						>
42 | 							{Schedule.dayLabels[day]}
43 | 						</div>
44 | 					))}
45 | 					<div className="column time-column">
46 | 						{timeColumn.map(slot => (
47 | 							<ColumnCell key={slot.start} slot={slot} />
48 | 						))}
49 | 					</div>
50 | 					{columns.map((slots, i) => (
51 | 						<div key={i} className="column">
52 | 							{slots.map(slot => (
53 | 								<ColumnCell key={slot.key} slot={slot} />
54 | 							))}
55 | 						</div>
56 | 					))}
57 | 				</div>
58 | 			</div>
59 | 		</div>
60 | 	);
61 | }
62 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ScheduleActions.tsx:
--------------------------------------------------------------------------------
 1 | import './ScheduleActions.css';
 2 | import MaximizeIcon from '../icons/MaximizeIcon';
 3 | import MinimizeIcon from '../icons/MinimizeIcon';
 4 | import BorderlessButton from './BorderlessButton';
 5 | import IconLink from './IconLink';
 6 | import GitHubIcon from '../icons/GitHubIcon';
 7 | import CollapseIcon from '../icons/CollapseIcon';
 8 | import ExpandIcon from '../icons/ExpandIcon';
 9 | import Title from './Title';
10 | import FilterIcon from '../icons/FilterIcon';
11 | 
12 | export default function ScheduleActions({
13 | 	shown,
14 | 	onShownChanged,
15 | 	miniMode,
16 | 	onMiniModeChanged,
17 | 	onFilterToggleClicked
18 | }: Readonly<{
19 | 	shown: boolean;
20 | 	onShownChanged: (shown: boolean) => void;
21 | 	miniMode: boolean;
22 | 	onMiniModeChanged: (miniMode: boolean) => void;
23 | 	onFilterToggleClicked: () => void;
24 | }>) {
25 | 	return (
26 | 		<header className="schedule-planner-header">
27 | 			<BorderlessButton onClick={() => onShownChanged(!shown)}>
28 | 				{shown ? <CollapseIcon /> : <ExpandIcon />}
29 | 			</BorderlessButton>
30 | 			<Title />
31 | 			{shown && (
32 | 				<>
33 | 					<BorderlessButton onClick={() => onFilterToggleClicked()}>
34 | 						<FilterIcon />
35 | 					</BorderlessButton>
36 | 					<BorderlessButton onClick={() => onMiniModeChanged(!miniMode)}>
37 | 						{miniMode ? <MaximizeIcon /> : <MinimizeIcon />}
38 | 					</BorderlessButton>
39 | 				</>
40 | 			)}
41 | 			<div className="header-external-links">
42 | 				{' '}
43 | 				<IconLink
44 | 					target="_blank"
45 | 					href="https://github.com/BrandonXLF/quest-plus"
46 | 					rel="noreferrer"
47 | 					icon={<GitHubIcon />}
48 | 				>
49 | 					GitHub
50 | 				</IconLink>
51 | 			</div>
52 | 		</header>
53 | 	);
54 | }
55 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/ClassSlot.ts:
--------------------------------------------------------------------------------
 1 | import { Day } from './Schedule';
 2 | import Class from './Class';
 3 | import ClassTime from './ClassTime';
 4 | 
 5 | export default class ClassSlot {
 6 | 	private static DATE_TIME_PATTERN =
 7 | 		/([A-Za-z]+) (\d+):(\d+)(AM|PM) - (\d+):(\d+)(AM|PM)/;
 8 | 
 9 | 	static fromString(classInfo: Class, dateTimeStr: string, room: string) {
10 | 		if (!ClassSlot.DATE_TIME_PATTERN.test(dateTimeStr)) return undefined;
11 | 
12 | 		const [
13 | 			,
14 | 			daysStr,
15 | 			startHour,
16 | 			startMin,
17 | 			startPeriod,
18 | 			endHour,
19 | 			endMin,
20 | 			endPeriod
21 | 		] = ClassSlot.DATE_TIME_PATTERN.exec(dateTimeStr)!;
22 | 
23 | 		const start = new ClassTime(
24 | 			startHour,
25 | 			startMin,
26 | 			startPeriod as 'AM' | 'PM'
27 | 		);
28 | 		const end = new ClassTime(endHour, endMin, endPeriod as 'AM' | 'PM');
29 | 		const days = daysStr.split(/(?=[A-Z])/) as Day[];
30 | 
31 | 		return new ClassSlot(classInfo, start, end, days, room);
32 | 	}
33 | 
34 | 	constructor(
35 | 		public classInfo: Class,
36 | 		public start: ClassTime,
37 | 		public end: ClassTime,
38 | 		public days: Day[],
39 | 		public room: string
40 | 	) {}
41 | 
42 | 	get timeStr() {
43 | 		return `${this.start}\u2013${this.end}`;
44 | 	}
45 | 
46 | 	get dayStr() {
47 | 		return this.days.join('');
48 | 	}
49 | 
50 | 	async getDateStr() {
51 | 		const dates = await this.dates;
52 | 
53 | 		if (!dates.start.isDefined()) return '';
54 | 
55 | 		if (dates.start.valueOf() === dates.end.valueOf())
56 | 			return dates.start.toString();
57 | 
58 | 		return `${dates.start}\u2013${dates.end}`;
59 | 	}
60 | 
61 | 	get uniqueStr() {
62 | 		return `${this.timeStr} ${this.dayStr} ${this.room}`;
63 | 	}
64 | 
65 | 	get dates() {
66 | 		return this.classInfo.getDatesForSlot(this);
67 | 	}
68 | }
69 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ColumnCell.tsx:
--------------------------------------------------------------------------------
 1 | import ClassSubCell from './ClassSubCell';
 2 | import './ColumnCell.css';
 3 | import ScheduleSlot, { SlotType } from '../data/ScheduleSlot';
 4 | import { useEffect, useState } from 'react';
 5 | 
 6 | export default function ColumnCell({ slot }: Readonly<{ slot: ScheduleSlot }>) {
 7 | 	const [className, setClassName] = useState('');
 8 | 
 9 | 	useEffect(() => {
10 | 		if (slot.type !== SlotType.Class) {
11 | 			setClassName(slot.type);
12 | 			return;
13 | 		}
14 | 
15 | 		const classType = slot.classSlots.every(
16 | 			classSlot =>
17 | 				classSlot.classInfo.type &&
18 | 				classSlot.classInfo.type === slot.classSlots[0].classInfo.type
19 | 		)
20 | 			? `${slot.classSlots[0].classInfo.type}`
21 | 			: 'MULTI';
22 | 
23 | 		(async () => {
24 | 			const types: string[] = [];
25 | 
26 | 			for (const classSlot of slot.classSlots)
27 | 				types.push(await classSlot.classInfo.getType());
28 | 
29 | 			const classType = types.every(type => type === types[0])
30 | 				? `${types[0]}`
31 | 				: 'MULTI';
32 | 
33 | 			setClassName(`${slot.type} class-${classType}`);
34 | 		})();
35 | 
36 | 		setClassName(`${slot.type} class-${classType}`);
37 | 	}, [slot]);
38 | 
39 | 	if (slot.start === slot.end) return null;
40 | 
41 | 	const height = ((slot.end - slot.start) / 10) * 1.75 + 'em';
42 | 
43 | 	return (
44 | 		<div style={{ height }} className={`column-slot ${className}`}>
45 | 			<div className="cell-content">
46 | 				{'classSlots' in slot
47 | 					? slot.classSlots.map(classSlot => (
48 | 						<ClassSubCell
49 | 							key={classSlot.uniqueStr}
50 | 							classSlot={classSlot}
51 | 							siblings={slot.classSlots}
52 | 							expandable={slot.classSlots.length > 1}
53 | 						/>
54 | 					))
55 | 					: slot.content}
56 | 			</div>
57 | 		</div>
58 | 	);
59 | }
60 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/Main.tsx:
--------------------------------------------------------------------------------
 1 | import { useMemo, useRef, useState } from 'react';
 2 | import './Main.css';
 3 | import ScheduleGrid from './ScheduleGrid';
 4 | import useConfigBoolean from '../helpers/UseConfigBoolean';
 5 | import ScheduleActions from './ScheduleActions';
 6 | import getQuestParser from '../data/getQuestParser';
 7 | import ClassToggleList from './ClassToggleList';
 8 | 
 9 | export default function Main() {
10 | 	const parser = useRef(getQuestParser());
11 | 	const classes = parser.current?.parse();
12 | 
13 | 	const [shown, setShown] = useConfigBoolean('show-timetable', true);
14 | 	const [miniMode, setMiniMode] = useConfigBoolean('mini-timetable', false);
15 | 	const [hiddenClasses, setHiddenClasses] = useState<Record<string, boolean>>(
16 | 		{}
17 | 	);
18 | 	const [showFilter, setShowFilter] = useState(false);
19 | 	const filteredClasses = useMemo(
20 | 		() =>
21 | 			classes?.filter(
22 | 				classInfo => hiddenClasses[classInfo.identifier] !== true
23 | 			),
24 | 		[classes, hiddenClasses]
25 | 	);
26 | 
27 | 	if (!classes) return;
28 | 
29 | 	return (
30 | 		<article className="schedule-planner">
31 | 			<ScheduleActions
32 | 				shown={shown}
33 | 				onShownChanged={setShown}
34 | 				miniMode={miniMode}
35 | 				onMiniModeChanged={setMiniMode}
36 | 				onFilterToggleClicked={() => setShowFilter(showFilter => !showFilter)}
37 | 			/>
38 | 			{shown && showFilter && (
39 | 				<ClassToggleList
40 | 					classes={classes}
41 | 					hiddenClasses={hiddenClasses}
42 | 					onHiddenClassesChanged={changes => {
43 | 						setHiddenClasses(hiddenClasses => ({
44 | 							...hiddenClasses,
45 | 							...changes
46 | 						}));
47 | 					}}
48 | 				/>
49 | 			)}
50 | 			{shown && filteredClasses && (
51 | 				<ScheduleGrid classes={filteredClasses} isMini={miniMode} />
52 | 			)}
53 | 		</article>
54 | 	);
55 | }
56 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ColumnCell.css:
--------------------------------------------------------------------------------
 1 | .column-slot {
 2 | 	display: flex;
 3 | 	align-items: center;
 4 | 	justify-content: center;
 5 | 	position: relative;
 6 | 	border: 0 solid var(--border-color);
 7 | 	border-width: 0 0 1px 0;
 8 | 	overflow: hidden;
 9 | }
10 | 
11 | .mini .column-slot {
12 | 	height: max-content !important;
13 | }
14 | 
15 | .mini .class {
16 | 	border-left-width: 1px;
17 | 	border-right-width: 1px;
18 | }
19 | 
20 | .schedule:not(.mini) .class:hover {
21 | 	overflow: visible;
22 | }
23 | 
24 | .gap {
25 | 	color: var(--lighter);
26 | }
27 | 
28 | .mini .blank {
29 | 	display: none;
30 | }
31 | 
32 | .cell-content {
33 | 	padding: 3px;
34 | 	width: 100%;
35 | 	min-height: 100%;
36 | 	display: flex;
37 | 	flex-direction: column;
38 | 	justify-content: center;
39 | 	text-align: center;
40 | }
41 | 
42 | .mini .cell-content {
43 | 	padding: 6px 3px;
44 | }
45 | 
46 | .class .cell-content {
47 | 	background: var(--bg-darker);
48 | }
49 | 
50 | .schedule:not(.mini) .class .cell-content {
51 | 	position: absolute;
52 | 	top: 0;
53 | 	left: 0;
54 | 	transition:
55 | 		left 15ms linear,
56 | 		top 15ms linear,
57 | 		border-color 15ms linear,
58 | 		box-shadow 15ms linear;
59 | }
60 | 
61 | .class-GET_STARTED .cell-content {
62 | 	font-size: 125%;
63 | }
64 | 
65 | .class-LEC .cell-content {
66 | 	background: var(--bg-blue);
67 | }
68 | 
69 | .class-TUT .cell-content {
70 | 	background: var(--bg-purple);
71 | }
72 | 
73 | .class-TST .cell-content {
74 | 	background: var(--bg-green);
75 | }
76 | 
77 | .class-LAB .cell-content {
78 | 	background: var(--bg-orange);
79 | }
80 | 
81 | .class-SEM .cell-content {
82 | 	background: var(--bg-yellow);
83 | }
84 | 
85 | .schedule:not(.mini) .class:hover .cell-content {
86 | 	top: -3px;
87 | 	left: -3px;
88 | 	box-shadow:
89 | 		var(--border-color) 3px 3px 0px 0px,
90 | 		var(--border-color) 0px 0px 0px 1px;
91 | 	z-index: 1;
92 | }
93 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/CartParser.ts:
--------------------------------------------------------------------------------
 1 | import Class from './Class';
 2 | import ClassSlot from './ClassSlot';
 3 | import QuestParser from './QuestParser';
 4 | 
 5 | export default class CartParser extends QuestParser {
 6 | 	static readonly NAME_REGEX = /^([A-Z]+) (\d+[A-Z]?)-(\d+)\n\((\d+)\)/;
 7 | 	static readonly DESC_REGEX = /^(.+) \(([A-Z]+)\)/;
 8 | 
 9 | 	private seen: Record<string, Class> = {};
10 | 
11 | 	parseName(name: string) {
12 | 		const res = CartParser.NAME_REGEX.exec(name);
13 | 
14 | 		if (!res) return ['', '', '', ''] as [string, string, string, string];
15 | 
16 | 		res.splice(0, 1);
17 | 
18 | 		return res as string[] as [string, string, string, string];
19 | 	}
20 | 
21 | 	parseDesc(desc: string) {
22 | 		const res = CartParser.DESC_REGEX.exec(desc);
23 | 
24 | 		if (!res) return ['', 'UKN'] as const;
25 | 
26 | 		return [res[2], res[1]] as const;
27 | 	}
28 | 
29 | 	importRows(rows: HTMLTableRowElement[], cart: boolean) {
30 | 		return rows
31 | 			.map(row => {
32 | 				const classInfo = new Class(
33 | 					...this.parseName(this.getChildContents(row, 'CLASS_NAME')),
34 | 					...this.parseDesc(this.getChildContents(row, 'CLASS_DESCR')),
35 | 					this.getChildContents(row, 'INSTR'),
36 | 					cart
37 | 				);
38 | 
39 | 				if (this.seen[classInfo.identifier]) {
40 | 					this.seen[classInfo.identifier].cart &&= cart;
41 | 					return undefined;
42 | 				}
43 | 
44 | 				this.seen[classInfo.identifier] = classInfo;
45 | 
46 | 				const slot = ClassSlot.fromString(
47 | 					classInfo,
48 | 					this.getChildContents(row, 'SCHED'),
49 | 					this.getChildContents(row, 'LOC')
50 | 				);
51 | 
52 | 				if (slot) classInfo.slots.push(slot);
53 | 
54 | 				return classInfo;
55 | 			})
56 | 			.filter(Boolean) as Class[];
57 | 	}
58 | 
59 | 	parse() {
60 | 		const result = [
61 | 			...this.importRows(
62 | 				[
63 | 					...document.querySelectorAll<HTMLTableRowElement>(
64 | 						'[id^="trSSR_REGFORM_VW$"]'
65 | 					)
66 | 				],
67 | 				true
68 | 			),
69 | 			...this.importRows(
70 | 				[
71 | 					...document.querySelectorAll<HTMLTableRowElement>(
72 | 						'[id^="trSTDNT_ENRL_SSVW$"]'
73 | 					)
74 | 				],
75 | 				false
76 | 			)
77 | 		];
78 | 
79 | 		this.seen = {};
80 | 
81 | 		return result;
82 | 	}
83 | }
84 | 


--------------------------------------------------------------------------------
/src/flow-links/initFlowLinks.ts:
--------------------------------------------------------------------------------
 1 | import getInstructorUWFlow from '../helpers/getInstructorUWFlow';
 2 | 
 3 | function makeLinkModifier(func: (el: HTMLElement, text: string) => void) {
 4 | 	return (el: HTMLElement) => {
 5 | 		if (el.dataset.questPlusProcessed) return;
 6 | 
 7 | 		if (!el.dataset.questPlusInnerText) {
 8 | 			// Used by other Quest+ tools
 9 | 			el.dataset.questPlusInnerText = el.innerText;
10 | 		}
11 | 
12 | 		const text = el.dataset.questPlusInnerText.trim();
13 | 
14 | 		func(el, text);
15 | 
16 | 		el.dataset.questPlusProcessed = 'true';
17 | 	};
18 | }
19 | 
20 | function createUWFlowLink(prefix: string, target: string, text: string) {
21 | 	const link = document.createElement('a');
22 | 
23 | 	link.href = 'https://uwflow.com' + prefix + encodeURIComponent(target);
24 | 	link.textContent = '\u25C9 ' + text;
25 | 	link.className = 'PSHYPERLINK';
26 | 	link.target = 'quest-plus-uw-flow';
27 | 	link.style.color = 'rgb(0, 82, 204)';
28 | 
29 | 	return link;
30 | }
31 | 
32 | const insertCourseLink = makeLinkModifier((el: HTMLElement, text: string) => {
33 | 	const parts = /^([A-Z]+)\s+([A-Z0-9]+).*/.exec(text);
34 | 
35 | 	el.replaceChildren(
36 | 		createUWFlowLink('/course/', (parts![1] + parts![2]).toLowerCase(), text)
37 | 	);
38 | });
39 | 
40 | const prependCourseLink = makeLinkModifier((el: HTMLElement, text: string) => {
41 | 	const parts = /^([A-Z]+)\s+([A-Z0-9]+).*/.exec(text);
42 | 
43 | 	el.replaceChildren(
44 | 		'(',
45 | 		createUWFlowLink(
46 | 			'/course/',
47 | 			(parts![1] + parts![2]).toLowerCase(),
48 | 			parts![1] + ' ' + parts![2]
49 | 		),
50 | 		') ',
51 | 		text
52 | 	);
53 | });
54 | 
55 | const insertInstructorLink = makeLinkModifier(
56 | 	(el: HTMLElement, names: string) => {
57 | 		const links = names.split(',').flatMap((rawName, i) => {
58 | 			const name = rawName.trim();
59 | 			const url = getInstructorUWFlow(name);
60 | 			const show = url ? createUWFlowLink(url, '', name) : name;
61 | 
62 | 			if (i > 0) return [', ', show];
63 | 
64 | 			return [show];
65 | 		});
66 | 
67 | 		el.replaceChildren(...links);
68 | 
69 | 		el.dataset.questPlusProcessed = 'true';
70 | 	}
71 | );
72 | 
73 | export default function initFlowLinks() {
74 | 	[
75 | 		...document.querySelectorAll<HTMLElement>(
76 | 			'[id*="SSR_CLSRSLT_WRK_GROUPBOX2GP"], [id*="DERIVED_REGFRM1_DESCR20"] .PAGROUPDIVIDER, [id*="DERIVED_CLS_DTL_DESCR50"]'
77 | 		)
78 | 	].forEach(insertCourseLink);
79 | 
80 | 	[
81 | 		...document.querySelectorAll<HTMLElement>(
82 | 			'[id*="E_CLASS_NAME"], [id*="R_CLASS_NAME"]'
83 | 		)
84 | 	].forEach(prependCourseLink);
85 | 
86 | 	[
87 | 		...document.querySelectorAll<HTMLElement>(
88 | 			'[id*="MTG_INSTR"], [id*="DERIVED_CLS_DTL_SSR_INSTR_LONG"], [id*="DERIVED_REGFRM1_SSR_INSTR_LONG"]'
89 | 		)
90 | 	].forEach(insertInstructorLink);
91 | }
92 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/components/ClassSubCell.tsx:
--------------------------------------------------------------------------------
  1 | import { useEffect, useState } from 'react';
  2 | import './ClassSubCell.css';
  3 | import ClassSlot from '../data/ClassSlot';
  4 | import CollapseIcon from '../icons/CollapseIcon';
  5 | import ExpandIcon from '../icons/ExpandIcon';
  6 | import BorderlessButton from './BorderlessButton';
  7 | import OverlapIcon from '../icons/OverlapIcon';
  8 | import UWFlowLink from './UWFlowLink';
  9 | import AsyncContent from './AsyncContent';
 10 | import CartIcon from '../icons/CartIcon';
 11 | import getInstructorUWFlow from '../../helpers/getInstructorUWFlow';
 12 | 
 13 | export default function ClassSubCell({
 14 | 	classSlot,
 15 | 	expandable,
 16 | 	siblings = []
 17 | }: Readonly<{
 18 | 	classSlot: ClassSlot;
 19 | 	expandable?: boolean;
 20 | 	siblings?: ClassSlot[];
 21 | }>) {
 22 | 	const [expanded, setExpanded] = useState(false);
 23 | 	const [overlaps, setOverlaps] = useState(false);
 24 | 
 25 | 	useEffect(() => {
 26 | 		(async () => {
 27 | 			const dates = [];
 28 | 
 29 | 			for (const sibling of siblings) {
 30 | 				if (sibling === classSlot) continue;
 31 | 
 32 | 				dates.push(await sibling.dates);
 33 | 			}
 34 | 
 35 | 			const thisDates = await classSlot.dates;
 36 | 
 37 | 			setOverlaps(
 38 | 				dates.some(
 39 | 					datePair =>
 40 | 						thisDates.end >= datePair.start && thisDates.start <= datePair.end
 41 | 				)
 42 | 			);
 43 | 		})();
 44 | 	}, [classSlot, siblings]);
 45 | 
 46 | 	return (
 47 | 		<>
 48 | 			<div className="slot-top">
 49 | 				{overlaps && (
 50 | 					<>
 51 | 						<OverlapIcon />{' '}
 52 | 					</>
 53 | 				)}
 54 | 				{classSlot.classInfo.cart && (
 55 | 					<>
 56 | 						<CartIcon />{' '}
 57 | 					</>
 58 | 				)}
 59 | 				<UWFlowLink
 60 | 					path={`/course/${classSlot.classInfo.code
 61 | 						.toLowerCase()
 62 | 						.replace(/ /g, '')}`}
 63 | 				>
 64 | 					{classSlot.classInfo.code}
 65 | 				</UWFlowLink>{' '}
 66 | 				<span>{classSlot.classInfo.section}</span>{' '}
 67 | 				<span>
 68 | 					{
 69 | 						<AsyncContent
 70 | 							load={() => classSlot.classInfo.getType()}
 71 | 							deps={[classSlot.classInfo]}
 72 | 						/>
 73 | 					}
 74 | 				</span>{' '}
 75 | 				<span>({classSlot.classInfo.classNumber})</span>
 76 | 				{expandable && (
 77 | 					<>
 78 | 						{' '}
 79 | 						<BorderlessButton onClick={() => setExpanded(!expanded)}>
 80 | 							{expanded ? <CollapseIcon /> : <ExpandIcon />}
 81 | 						</BorderlessButton>
 82 | 					</>
 83 | 				)}
 84 | 			</div>
 85 | 			{(!expandable || expanded) && (
 86 | 				<div className="expanded-content">
 87 | 					<div>
 88 | 						<span>{classSlot.room}</span>{' '}
 89 | 						{classSlot.classInfo.instructors.flatMap((name, i) => {
 90 | 							const url = getInstructorUWFlow(name);
 91 | 							const displayName =
 92 | 								name === 'To be Announced' ? 'Instructor TBA' : name;
 93 | 
 94 | 							const show = url ? (
 95 | 								<UWFlowLink path={url}>{displayName}</UWFlowLink>
 96 | 							) : (
 97 | 								displayName
 98 | 							);
 99 | 
100 | 							if (i > 0) return [', ', show];
101 | 
102 | 							return [show];
103 | 						})}{' '}
104 | 						<span>
105 | 							<AsyncContent
106 | 								load={() => classSlot.classInfo.getEnrolledString()}
107 | 								deps={[classSlot.classInfo]}
108 | 							/>
109 | 						</span>
110 | 					</div>
111 | 					<div>
112 | 						<span>{classSlot.timeStr}</span>{' '}
113 | 						<span>
114 | 							{' '}
115 | 							<AsyncContent
116 | 								load={() => classSlot.getDateStr()}
117 | 								deps={[classSlot]}
118 | 							/>
119 | 						</span>
120 | 					</div>
121 | 				</div>
122 | 			)}
123 | 		</>
124 | 	);
125 | }
126 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/SupplementaryParser.ts:
--------------------------------------------------------------------------------
  1 | import ClassDate from './ClassDate';
  2 | import ClassesParser from './ClassesParser';
  3 | import { SupplementaryInfo } from './SupplementaryInfo';
  4 | 
  5 | export default class SupplementaryParser extends ClassesParser {
  6 | 	private static classCache: Record<string, Record<string, SupplementaryInfo>> =
  7 | 		{};
  8 | 	private static nameCache: Record<string, string> = {};
  9 | 	private static digitRegex = /^\d+$/;
 10 | 	private static dateRegex = /[0-9:]+-[0-9:]+[A-Za-z]+([^-]*|)-?(.*|)/;
 11 | 
 12 | 	private classes: Record<string, SupplementaryInfo> = {};
 13 | 	private outerTableRows?: HTMLTableRowElement[];
 14 | 	private scheduleRows?: HTMLTableRowElement[];
 15 | 	private currentClass?: SupplementaryInfo;
 16 | 
 17 | 	static async getSupplementaryInfo(
 18 | 		session: string,
 19 | 		subject: string,
 20 | 		number: string,
 21 | 		classNumber: string
 22 | 	) {
 23 | 		const parser = new SupplementaryParser(session, subject, number);
 24 | 
 25 | 		return (await parser.getClasses())[classNumber];
 26 | 	}
 27 | 
 28 | 	constructor(
 29 | 		public session: string,
 30 | 		public subject: string,
 31 | 		public number: string
 32 | 	) {
 33 | 		super();
 34 | 	}
 35 | 
 36 | 	get code() {
 37 | 		return `${this.subject} ${this.number}`;
 38 | 	}
 39 | 
 40 | 	private datesFromRow(row: HTMLTableRowElement, colOffset: number = 0) {
 41 | 		const dateText = this.getCellContents(row, 10 + colOffset);
 42 | 
 43 | 		if (!this.currentClass || !SupplementaryParser.dateRegex.test(dateText))
 44 | 			return false;
 45 | 
 46 | 		const [, startDateStr, endDateStr] =
 47 | 			SupplementaryParser.dateRegex.exec(dateText)!;
 48 | 
 49 | 		this.currentClass.slotDates.push({
 50 | 			start: new ClassDate(startDateStr),
 51 | 			end: new ClassDate(endDateStr)
 52 | 		});
 53 | 
 54 | 		return true;
 55 | 	}
 56 | 
 57 | 	private async classFromRow(row: HTMLTableRowElement) {
 58 | 		const number = this.getCellContents(row, 0);
 59 | 
 60 | 		this.currentClass = new SupplementaryInfo(
 61 | 			await this.getName(),
 62 | 			this.getCellContents(row, 1).split(' ')[0],
 63 | 			this.getCellContents(row, 2),
 64 | 			+this.getCellContents(row, 7),
 65 | 			+this.getCellContents(row, 6)
 66 | 		);
 67 | 
 68 | 		if (!this.datesFromRow(row)) {
 69 | 			delete this.classes[number];
 70 | 			return;
 71 | 		}
 72 | 
 73 | 		this.classes[number] = this.currentClass;
 74 | 	}
 75 | 
 76 | 	private async processRow(row: HTMLTableRowElement) {
 77 | 		const firstCell = this.getCellContents(row, 0);
 78 | 		const firstIsNumber = SupplementaryParser.digitRegex.test(firstCell);
 79 | 
 80 | 		if (firstIsNumber) {
 81 | 			await this.classFromRow(row);
 82 | 			return;
 83 | 		}
 84 | 
 85 | 		this.datesFromRow(row, !firstCell ? 0 : -5);
 86 | 	}
 87 | 
 88 | 	private async populateTableRows() {
 89 | 		[this.outerTableRows, this.scheduleRows] = await this.fetchTableRows(
 90 | 			`/cgi-bin/cgiwrap/infocour/salook.pl?level=under&sess=${this.session}&subject=${this.subject}&cournum=${this.number}`,
 91 | 			[0, 1]
 92 | 		);
 93 | 	}
 94 | 
 95 | 	async getClasses() {
 96 | 		if (this.code in SupplementaryParser.classCache)
 97 | 			return SupplementaryParser.classCache[this.code];
 98 | 
 99 | 		this.classes = {};
100 | 
101 | 		if (!this.scheduleRows) await this.populateTableRows();
102 | 
103 | 		for (const row of this.scheduleRows!.filter((_, i) => i)) {
104 | 			await this.processRow(row);
105 | 		}
106 | 
107 | 		SupplementaryParser.classCache[this.code] = this.classes;
108 | 		return this.classes;
109 | 	}
110 | 
111 | 	async getName() {
112 | 		if (this.code in SupplementaryParser.nameCache)
113 | 			return SupplementaryParser.nameCache[this.code];
114 | 
115 | 		if (!this.outerTableRows) await this.populateTableRows();
116 | 		if (!this.outerTableRows![1]) return '';
117 | 
118 | 		const name = this.getCellContents(this.outerTableRows![1], 3);
119 | 		SupplementaryParser.nameCache[this.code] = name;
120 | 		return name;
121 | 	}
122 | }
123 | 


--------------------------------------------------------------------------------
/src/schedule-visualizer/data/Schedule.tsx:
--------------------------------------------------------------------------------
  1 | import Class from './Class';
  2 | import ScheduleSlot, { SlotType } from './ScheduleSlot';
  3 | 
  4 | type ScheduleSlotWithKey = ScheduleSlot & { key: string };
  5 | 
  6 | export type Day = (typeof Schedule.days)[number];
  7 | 
  8 | export default class Schedule {
  9 | 	static readonly days = ['M', 'T', 'W', 'Th', 'F'] as const;
 10 | 
 11 | 	static readonly dayLabels: Record<Day, string> = {
 12 | 		M: 'Mon',
 13 | 		T: 'Tue',
 14 | 		W: 'Wed',
 15 | 		Th: 'Thu',
 16 | 		F: 'Fri'
 17 | 	};
 18 | 
 19 | 	columns: ScheduleSlotWithKey[][] = [];
 20 | 	start = Infinity;
 21 | 	end = 0;
 22 | 	hasClassSlots = false;
 23 | 
 24 | 	constructor(private classes: Class[]) {}
 25 | 
 26 | 	createColumns() {
 27 | 		this.columns = Schedule.days.map(() => []);
 28 | 
 29 | 		this.classes.forEach(classInfo => {
 30 | 			classInfo.slots.forEach(classSlot => {
 31 | 				classSlot.days.forEach(day => {
 32 | 					this.hasClassSlots = true;
 33 | 
 34 | 					this.columns[Schedule.days.indexOf(day)].push({
 35 | 						type: SlotType.Class,
 36 | 						start: classSlot.start.index,
 37 | 						end: classSlot.end.index,
 38 | 						classSlots: [classSlot],
 39 | 						key: `${classInfo.courseNumber}/${classSlot.uniqueStr}/${day}`
 40 | 					});
 41 | 				});
 42 | 			});
 43 | 		});
 44 | 	}
 45 | 
 46 | 	processClassOverlap(
 47 | 		slots: ScheduleSlotWithKey[],
 48 | 		i: number,
 49 | 		slot: ScheduleSlotWithKey,
 50 | 		prevSlot: ScheduleSlotWithKey
 51 | 	) {
 52 | 		if (!('classSlots' in prevSlot) || !('classSlots' in slot))
 53 | 			throw new Error('Slots must have classSlots');
 54 | 
 55 | 		const prevSlotEnd = prevSlot.end;
 56 | 		const overlapStart = slot.start;
 57 | 		const overlapEnd = Math.min(prevSlot.end, slot.end);
 58 | 
 59 | 		prevSlot.end = overlapStart;
 60 | 		slot.start = overlapEnd;
 61 | 
 62 | 		const newSlots = [...prevSlot.classSlots, ...slot.classSlots];
 63 | 
 64 | 		slots.splice(i, 0, {
 65 | 			type: SlotType.Class,
 66 | 			start: overlapStart,
 67 | 			end: overlapEnd,
 68 | 			classSlots: newSlots,
 69 | 			key: `${prevSlot.key}+${slot.key}`
 70 | 		});
 71 | 
 72 | 		i++;
 73 | 
 74 | 		if (slot.end === overlapEnd) {
 75 | 			slots.splice(i, 1);
 76 | 			i--;
 77 | 		}
 78 | 
 79 | 		if (prevSlotEnd > overlapEnd) {
 80 | 			let insertIndex = i + 1;
 81 | 
 82 | 			while (slots[insertIndex]?.start < overlapEnd) insertIndex++;
 83 | 
 84 | 			slots.splice(insertIndex, 0, {
 85 | 				...prevSlot,
 86 | 				start: overlapEnd,
 87 | 				end: prevSlotEnd,
 88 | 				key: `${prevSlot.key}/split`
 89 | 			});
 90 | 
 91 | 			if (insertIndex == i + 1) i++;
 92 | 		}
 93 | 
 94 | 		return i;
 95 | 	}
 96 | 
 97 | 	processSlots(slots: ScheduleSlotWithKey[]) {
 98 | 		slots.sort((a, b) => a.start - b.start);
 99 | 
100 | 		if (slots.length && slots[0].start < this.start)
101 | 			this.start = slots[0].start;
102 | 
103 | 		for (let i = 0; i < slots.length; i++) {
104 | 			const prevSlot = slots[i - 1] as (typeof slots)[0] | undefined;
105 | 			const slot = slots[i];
106 | 
107 | 			if (slot.end > this.end) this.end = slot.end;
108 | 
109 | 			if (!prevSlot) continue;
110 | 
111 | 			if (prevSlot.end > slot.start) {
112 | 				i = this.processClassOverlap(slots, i, slot, prevSlot);
113 | 				continue;
114 | 			}
115 | 
116 | 			slots.splice(i, 0, {
117 | 				type: SlotType.Gap,
118 | 				start: prevSlot.end,
119 | 				end: slot.start,
120 | 				content: (
121 | 					<div>
122 | 						{Math.floor((slot.start - prevSlot.end) / 60)}:
123 | 						{Math.floor((slot.start - prevSlot.end) % 60)}
124 | 					</div>
125 | 				),
126 | 				key: `${prevSlot.key}+${slot.key}`
127 | 			});
128 | 
129 | 			i++;
130 | 		}
131 | 	}
132 | 
133 | 	addPaddingSlots(slots: ScheduleSlotWithKey[]) {
134 | 		if (!slots.length) {
135 | 			slots.push({
136 | 				type: SlotType.Blank,
137 | 				content: undefined,
138 | 				start: this.start,
139 | 				end: this.end,
140 | 				key: 'START'
141 | 			});
142 | 
143 | 			return;
144 | 		}
145 | 
146 | 		slots.unshift({
147 | 			type: SlotType.Blank,
148 | 			content: undefined,
149 | 			start: this.start,
150 | 			end: slots[0].start,
151 | 			key: 'START'
152 | 		});
153 | 
154 | 		slots.push({
155 | 			type: SlotType.Blank,
156 | 			content: undefined,
157 | 			start: slots[slots.length - 1].end,
158 | 			end: this.end,
159 | 			key: 'END'
160 | 		});
161 | 	}
162 | 
163 | 	prepareColumns() {
164 | 		this.createColumns();
165 | 
166 | 		this.columns.forEach(this.processSlots, this);
167 | 		this.columns.forEach(this.addPaddingSlots, this);
168 | 
169 | 		return this.columns;
170 | 	}
171 | 
172 | 	prepareTimeColumn() {
173 | 		const timeColumn: ScheduleSlot[] = [];
174 | 
175 | 		for (let i = this.start, nextI = 0; i < this.end; i = nextI) {
176 | 			let hour = Math.floor(i / 60);
177 | 			const minutes = i % 60;
178 | 
179 | 			if (hour > 12) hour -= 12;
180 | 
181 | 			nextI = Math.ceil((i + 1) / 60) * 60;
182 | 
183 | 			timeColumn.push({
184 | 				type: SlotType.Time,
185 | 				start: i,
186 | 				end: Math.min(nextI, this.end),
187 | 				content: <div>{`${hour}:${minutes.toString().padStart(2, '0')}`}</div>
188 | 			});
189 | 		}
190 | 
191 | 		return timeColumn;
192 | 	}
193 | }
194 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------