80 |
81 |
82 |
89 |
90 | Install the PlanMyTimetable Capture browser extension.
91 |
92 |
114 |
115 |
116 | *If you have a chromium
117 | based browser for example:
118 |
119 |
120 | Edge,
121 |
122 |
123 |
124 |
125 | Arc,
126 |
127 |
128 |
129 |
130 | Brave,
131 |
132 | or
133 |
134 |
135 | Opera,
136 |
137 | you can also use the Chrome web store to install the extension.
138 |
139 |
140 |
141 | );
142 | };
143 |
144 | const BookmarkTab = () => {
145 | return (
146 |
147 |
148 | -
149 | Bookmark the following code ( drag this into the bookmarks bar or
150 | right click and bookmark link ) :
151 |
152 |
173 |
174 | If you have concerns regarding privacy and security,
175 |
179 | checkout the source code
180 |
181 | . All data is stored locally and never leaves your computer.
182 |
183 | - Navigate to your Allocate+ system and login.
184 | - Click and run the bookmarklet on this page.
185 | - Select the semester you wish to plan for.
186 | - You will then be redirected to a new page with your data.
187 |
188 |
189 | );
190 | };
191 |
--------------------------------------------------------------------------------
/src/components/Calendar/generated/SortablePopover.tsx:
--------------------------------------------------------------------------------
1 | import {
2 | SortableContext,
3 | useSortable,
4 | verticalListSortingStrategy,
5 | sortableKeyboardCoordinates,
6 | arrayMove,
7 | } from "@dnd-kit/sortable";
8 | import { useEffect, useRef, useState } from "react";
9 | import type { Dispatch, SetStateAction } from "react";
10 | import Button from "../../Button/Button";
11 | import { HiMiniSparkles } from "react-icons/hi2";
12 | import {
13 | Dialog,
14 | DialogTrigger,
15 | DialogPortal,
16 | DialogOverlay,
17 | DialogContent,
18 | DialogClose,
19 | DialogTitle,
20 | DialogDescription,
21 | } from "@radix-ui/react-dialog";
22 | import { CSS } from "@dnd-kit/utilities";
23 | import {
24 | DndContext,
25 | closestCenter,
26 | KeyboardSensor,
27 | PointerSensor,
28 | useSensor,
29 | useSensors,
30 | } from "@dnd-kit/core";
31 | import type { DragEndEvent } from "@dnd-kit/core";
32 | import { RxDragHandleDots2 } from "react-icons/rx";
33 | import { HiOutlineX } from "react-icons/hi";
34 | import type { PENALTIES } from "./generate";
35 | import type { Preference } from "~/lib/definitions";
36 | import { usePreview } from "~/contexts/PreviewContext";
37 | import { getAllCampusDescriptions } from "~/lib/functions";
38 | import { ImSpinner8 } from "react-icons/im";
39 | import { useUrlState } from "~/hooks/useUrlState";
40 |
41 | export function SortablePopover({
42 | setGeneratedPreferences,
43 | setIndex,
44 | }: {
45 | setGeneratedPreferences: Dispatch
>;
46 | setIndex: Dispatch>;
47 | }) {
48 | const { courseData, events, setEvents } = usePreview();
49 | const [open, setOpen] = useState(false);
50 | const workerRef = useRef();
51 | const [isLoading, setIsLoading] = useState(false);
52 | const { replaceState, appendState } = useUrlState();
53 |
54 | const [items, setItems] = useState>([
55 | "breaks",
56 | "days",
57 | "campus",
58 | ]);
59 | const [preferredCampus, setPreferredCampus] = useState(
60 | getAllCampusDescriptions(courseData)[0] ?? "",
61 | );
62 | const sensors = useSensors(
63 | useSensor(PointerSensor),
64 | useSensor(KeyboardSensor, {
65 | coordinateGetter: sortableKeyboardCoordinates,
66 | }),
67 | );
68 |
69 | useEffect(() => {
70 | workerRef.current = new Worker(
71 | new URL("./generate.worker.ts", import.meta.url),
72 | );
73 | workerRef.current.onmessage = (event: MessageEvent) => {
74 | // console.log(event.data);
75 | setGeneratedPreferences(event.data);
76 | const newPreferences = event.data[0];
77 | if (newPreferences) {
78 | if (events.length === 0) {
79 | appendState(newPreferences, "pref");
80 | } else {
81 | replaceState(newPreferences, "pref");
82 | }
83 | setEvents(newPreferences);
84 | setIndex(0);
85 | }
86 | setIsLoading(false);
87 | };
88 | return () => {
89 | workerRef.current?.terminate();
90 | };
91 | }, [
92 | setGeneratedPreferences,
93 | appendState,
94 | events.length,
95 | replaceState,
96 | setEvents,
97 | setIndex,
98 | ]);
99 |
100 | const handleDragEnd = (event: DragEndEvent) => {
101 | const { active, over } = event;
102 | if (!over) {
103 | return;
104 | }
105 | if (active.id !== over?.id) {
106 | setItems((items) => {
107 | const oldIndex = items.indexOf(active.id as keyof typeof PENALTIES);
108 | const newIndex = items.indexOf(over.id as keyof typeof PENALTIES);
109 |
110 | return arrayMove(items, oldIndex, newIndex);
111 | });
112 | }
113 | };
114 |
115 | const generatePreferences = () => {
116 | setIsLoading(true);
117 | const options = {
118 | amount: 10,
119 | rankings: items,
120 | campus: preferredCampus,
121 | };
122 | // setGeneratedPreferences(generate(courseData, options));
123 | workerRef.current?.postMessage({ courses: courseData, options });
124 | };
125 |
126 | return (
127 |
198 | );
199 | }
200 |
201 | function SortableItem({ id, index }: { id: string; index: number }) {
202 | const { attributes, listeners, setNodeRef, transform, transition } =
203 | useSortable({ id: id });
204 | const style = {
205 | transform: CSS.Transform.toString(transform),
206 | transition,
207 | };
208 | return (
209 |
210 |
{index}:
211 |
218 | {id}
219 |
220 |
221 |
{children}
;
204 | }
205 |
--------------------------------------------------------------------------------
/src/app/(Navbar)/bmc.tsx:
--------------------------------------------------------------------------------
1 | export const BMCLogo = () => (
2 |
68 | );
69 |
--------------------------------------------------------------------------------
/src/components/Calendar/generated/generate.ts:
--------------------------------------------------------------------------------
1 | import { Days } from "~/lib/definitions";
2 | import type { Course, Preference, Time } from "~/lib/definitions";
3 | import { convertCourseToPreference } from "~/lib/functions";
4 |
5 | /*
6 | * This code is adapted from [Andogq Timetable project](https://github.com/andogq/timetable) to work with my types.
7 | * Copyright (C) 2022 Tom Anderson
8 | * Copyright (C) 2025 Maximus Dionyssopoulos
9 | *
10 | * This program is free software: you can redistribute it and/or modify
11 | * it under the terms of the GNU Affero General Public License as published by
12 | * the Free Software Foundation, either version 3 of the License, or
13 | * (at your option) any later version.
14 | *
15 | * This program is distributed in the hope that it will be useful,
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 | * GNU Affero General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU Affero General Public License
21 | * along with this program. If not, see .
22 | */
23 | interface GenerateOptions {
24 | amount?: number;
25 | log?: (message: string) => void;
26 | rankings: Array;
27 | campus: string;
28 | }
29 |
30 | export interface GenerateEvent {
31 | courses: Course[];
32 | options: GenerateOptions;
33 | }
34 |
35 | // Utility functions remain unchanged
36 | function timeToMinutes(time: string): number {
37 | const [hours, minutes] = time.split(":").map(Number);
38 | return hours! * 60 + minutes!;
39 | }
40 |
41 | function dayToNumber(day: Time["day"]): number {
42 | const dayMap: Record = {
43 | Mon: Days.Monday,
44 | Tue: Days.Tuesday,
45 | Wed: Days.Wednesday,
46 | Thu: Days.Thursday,
47 | Fri: Days.Friday,
48 | };
49 | return dayMap[day];
50 | }
51 |
52 | export const PENALTIES = {
53 | breaks: (intervals: Array<{ start: number; end: number }>): number => {
54 | return intervals.slice(1).reduce((sum, curr, idx) => {
55 | return sum + (curr.start - intervals[idx]!.end);
56 | }, 0);
57 | },
58 |
59 | days: (daysCount: number): number => daysCount,
60 |
61 | campus: (pref: Preference, targetCampus: string): number => {
62 | return pref.time.campus_description === targetCampus ? 0 : 1;
63 | },
64 | };
65 |
66 | interface TimetableState {
67 | timetable: Preference[];
68 | penalties: {
69 | breaks: number;
70 | days: number;
71 | campus: number;
72 | };
73 | scheduleHash: string;
74 | dayMap: Map>;
75 | dayCount: Set;
76 | courseIndex: number;
77 | }
78 |
79 | export function generate(
80 | courses: Course[],
81 | options: GenerateOptions,
82 | ): Preference[][] {
83 | const { amount = 10, log = console.log, rankings, campus } = options;
84 | const startTime = Date.now();
85 |
86 | const orderedCourses = [...courses].sort(
87 | (a, b) => a.options.length - b.options.length,
88 | );
89 |
90 | const topTimetables: TimetableState[] = [];
91 | const scheduleHashes = new Set();
92 | let worstScore = Infinity;
93 |
94 | const queue: TimetableState[] = [
95 | {
96 | timetable: [],
97 | penalties: { breaks: 0, days: 0, campus: 0 },
98 | dayMap: new Map(),
99 | dayCount: new Set(),
100 | courseIndex: 0,
101 | scheduleHash: "",
102 | },
103 | ];
104 |
105 | while (queue.length > 0) {
106 | const currentState = queue.pop()!;
107 |
108 | if (currentState.courseIndex === orderedCourses.length) {
109 | const hash = currentState.timetable
110 | .map((p) => `${p.time.day}-${p.time.start}-${p.time.duration}`)
111 | .sort()
112 | .join("|");
113 |
114 | if (!scheduleHashes.has(hash)) {
115 | scheduleHashes.add(hash);
116 | const score = rankings.reduce(
117 | (sum, rank) => sum + currentState.penalties[rank],
118 | 0,
119 | );
120 |
121 | if (score < worstScore || topTimetables.length < amount) {
122 | topTimetables.push({
123 | ...currentState,
124 | timetable: [...currentState.timetable],
125 | scheduleHash: hash,
126 | });
127 |
128 | topTimetables.sort((a, b) => {
129 | if (a.penalties.campus !== b.penalties.campus) {
130 | return a.penalties.campus - b.penalties.campus;
131 | }
132 | return rankings.reduce(
133 | (diff, rank) => diff || a.penalties[rank] - b.penalties[rank],
134 | 0,
135 | );
136 | });
137 |
138 | if (topTimetables.length > amount) {
139 | topTimetables.pop();
140 | worstScore = rankings.reduce(
141 | (sum, rank) =>
142 | sum + topTimetables[topTimetables.length - 1]!.penalties[rank],
143 | 0,
144 | );
145 | }
146 | }
147 | }
148 | continue;
149 | }
150 |
151 | const course = orderedCourses[currentState.courseIndex]!;
152 | const sortedOptions = [...course.options].sort((a, b) => {
153 | if (a.campus_description === campus) return -1;
154 | if (b.campus_description === campus) return 1;
155 | return 0;
156 | });
157 |
158 | for (const timeOption of sortedOptions) {
159 | const prefs = convertCourseToPreference(course, timeOption);
160 | const prefsArray = Array.isArray(prefs) ? prefs : [prefs];
161 |
162 | let isValid = true;
163 | const tempDayMap = new Map(currentState.dayMap);
164 |
165 | // Conflict check
166 | for (const pref of prefsArray) {
167 | const day = dayToNumber(pref.time.day);
168 | const start = timeToMinutes(pref.time.start);
169 | const end = start + pref.time.duration;
170 |
171 | const intervals = tempDayMap.get(day) ?? [];
172 | let low = 0,
173 | high = intervals.length;
174 | while (low < high) {
175 | const mid = (low + high) >>> 1;
176 | intervals[mid]!.start < start ? (low = mid + 1) : (high = mid);
177 | }
178 |
179 | if (
180 | (low > 0 && intervals[low - 1]!.end > start) ||
181 | (low < intervals.length && intervals[low]!.start < end)
182 | ) {
183 | isValid = false;
184 | break;
185 | }
186 |
187 | const newIntervals = [...intervals];
188 | newIntervals.splice(low, 0, { start, end });
189 | tempDayMap.set(day, newIntervals);
190 | }
191 |
192 | if (!isValid) continue;
193 |
194 | // Calculate penalties
195 | let breaksPenalty = 0;
196 | tempDayMap.forEach((intervals) => {
197 | breaksPenalty += PENALTIES.breaks(intervals);
198 | });
199 |
200 | const campusPenalty = prefsArray.reduce(
201 | (sum, pref) => sum + PENALTIES.campus(pref, campus),
202 | currentState.penalties.campus,
203 | );
204 |
205 | const daysCount = new Set([
206 | ...currentState.dayCount,
207 | ...prefsArray.map((p) => dayToNumber(p.time.day)),
208 | ]).size;
209 |
210 | const newState: TimetableState = {
211 | timetable: [...currentState.timetable, ...prefsArray],
212 | penalties: {
213 | breaks: breaksPenalty,
214 | days: daysCount,
215 | campus: campusPenalty,
216 | },
217 | dayMap: new Map(
218 | Array.from(tempDayMap.entries()).map(([k, v]) => [k, [...v]]),
219 | ),
220 | dayCount: new Set([
221 | ...currentState.dayCount,
222 | ...prefsArray.map((p) => dayToNumber(p.time.day)),
223 | ]),
224 | courseIndex: currentState.courseIndex + 1,
225 | scheduleHash: "",
226 | };
227 |
228 | const currentScore = rankings.reduce(
229 | (sum, rank) => sum + newState.penalties[rank],
230 | 0,
231 | );
232 |
233 | if (currentScore <= worstScore || topTimetables.length < amount) {
234 | let low = 0,
235 | high = queue.length;
236 | while (low < high) {
237 | const mid = (low + high) >>> 1;
238 | const midScore = rankings.reduce(
239 | (sum, rank) => sum + queue[mid]!.penalties[rank],
240 | 0,
241 | );
242 | currentScore < midScore ? (high = mid) : (low = mid + 1);
243 | }
244 | queue.splice(low, 0, newState);
245 | }
246 | }
247 | }
248 |
249 | log(
250 | `Generated ${topTimetables.length} unique timetables in ${
251 | Date.now() - startTime
252 | }ms`,
253 | );
254 | return topTimetables
255 | .sort((a, b) => {
256 | if (a.penalties.campus !== b.penalties.campus) {
257 | return a.penalties.campus - b.penalties.campus;
258 | }
259 | return rankings.reduce(
260 | (diff, rank) => diff || a.penalties[rank] - b.penalties[rank],
261 | 0,
262 | );
263 | })
264 | .slice(0, amount)
265 | .map((state) => state.timetable);
266 | }
267 |
--------------------------------------------------------------------------------
/public/bookmarklet.js:
--------------------------------------------------------------------------------
1 | /**
2 | * This script creates a popover window to select a semester and then fetches class data based on the selected semester.
3 | * The fetched data is processed and encoded before redirecting to a website with the encoded data.
4 | * The script also includes helper functions for swapping characters and crushing strings.
5 | */
6 | (() => {
7 | let semester;
8 | const semesters = Object.keys(window.data.student.student_enrolment_sem);
9 | let classes = [];
10 |
11 | const createWindow = async () => {
12 | // create popover to select semester
13 | let container = document.createElement("div");
14 | container.style.position = "fixed";
15 | container.style.top = "0";
16 | container.style.left = "0";
17 | container.style.right = "0";
18 | container.style.bottom = "0";
19 | container.style.background = "rgba(0, 0, 0, 0.5)";
20 | container.style.zIndex = "1000";
21 | container.style.display = "flex";
22 | container.style.justifyContent = "space-around";
23 | container.style.alignItems = "center";
24 |
25 | let loader = document.createElement("div");
26 | loader.style.padding = "5%";
27 | loader.style.display = "flex";
28 | loader.style.flexDirection = "column";
29 | loader.textContent = "Choose a semester: ";
30 | loader.style.background = "white";
31 | loader.style.fontFamily = "sans-serif";
32 |
33 | let form = document.createElement("form");
34 | form.style.background = "white";
35 | form.style.fontFamily = "sans-serif";
36 |
37 | // add semester radio buttons
38 | for (const [index, value] of semesters.entries()) {
39 | let radio = document.createElement("input");
40 | radio.type = "radio";
41 | radio.name = "semester";
42 | radio.value = index;
43 | radio.checked = index === 0;
44 | radio.id = value;
45 | let label = document.createElement("label");
46 | let span = document.createElement("span");
47 | span.innerHTML = value;
48 | label.appendChild(span);
49 | form.appendChild(label);
50 | form.appendChild(radio);
51 | }
52 |
53 | // create button and function run on click of button
54 | let submit = document.createElement("button");
55 | submit.textContent = "Next";
56 | submit.addEventListener("click", function (event) {
57 | // Prevent the form from being submitted
58 | event.preventDefault();
59 |
60 | // Get the value of the selected radio button
61 | semester = document.querySelector('input[name="semester"]:checked').value;
62 |
63 | // Log the selected value
64 | form.remove();
65 | loader.textContent = "Loading your timetable data...";
66 | run(
67 | () => container.remove(),
68 | (message) => {
69 | loader.innerText = message;
70 | },
71 | );
72 | });
73 | form.appendChild(submit);
74 | loader.appendChild(form);
75 |
76 | container.append(loader);
77 | document.body.append(container);
78 | };
79 |
80 | const selectType = (type) => {
81 | switch (type) {
82 | case "Lecture":
83 | return 0;
84 | case "Lectorial":
85 | return 0;
86 | case "Tutorial":
87 | return 1;
88 | case "Workshop":
89 | return 2;
90 | case "Practical":
91 | return 3;
92 | default:
93 | return 4;
94 | }
95 | };
96 |
97 | /**
98 | * Runs the bookmarklet code.
99 | *
100 | * @param {Function} close - The function to close the bookmarklet.
101 | * @param {Function} update - The function to update the bookmarklet.
102 | * @returns {Promise} - A promise that resolves when the bookmarklet code is executed successfully.
103 | */
104 | const run = async (close, update) => {
105 | try {
106 | // get all class data
107 | classes = await Promise.all(
108 | Object.values(
109 | window.data.student.student_enrolment_sem[semesters[semester]],
110 | ).map(async (course, index) => {
111 | return Promise.all(
112 | Object.values(course.groups).map(async (group) => {
113 | console.log(
114 | `Downloading group ${course.description} - ${group.activity_group_code}`,
115 | );
116 | const url = new URL(window.location.href);
117 | const token = url.searchParams.get("ss");
118 |
119 | const path_base = window.location.pathname
120 | .split("/")
121 | .slice(0, -1)
122 | .join("/");
123 |
124 | // create url to fetch data from
125 | const fetchUrl = new URL(
126 | `${url.origin}${path_base}/rest/student/${
127 | window.data.student.student_code
128 | }/subject/${course.subject_code}/group/${
129 | group.activity_group_code
130 | }/activities/?${"ss"}=${token}`,
131 | );
132 |
133 | // fetch individual class data
134 | const request = await fetch(fetchUrl);
135 |
136 | if (request.status === 200) {
137 | let data = await request.json();
138 | // create object for class
139 | const classs = {
140 | id: nanoid(),
141 | title: course.description,
142 | courseCode: course.callista_code ?? subject_code,
143 | type: selectType(Object.values(data)[0].activityType),
144 | colour: index,
145 | options: Object.values(data).map((item) => {
146 | const option = {
147 | day: item.day_of_week,
148 | start: item.start_time,
149 | duration: item.duration,
150 | location: item.location,
151 | campus_description: item.campus_description,
152 | };
153 | if (item.activity_code.match(/\d{2}-P[1-9]/g)) {
154 | option.grouped = true;
155 | option.grouped_code = item.activity_code;
156 | }
157 | return option;
158 | }),
159 | };
160 | return classs;
161 | } else {
162 | throw "Problem retreiving data. Please refresh the page and try again. If the problem persists, please open a new issue on Github.";
163 | }
164 | }),
165 | );
166 | }),
167 | );
168 | classes = classes.flat();
169 | // encode and redirect to site
170 | const encoded = encodeURIComponent(crush(JSON.stringify(classes)));
171 | window
172 | .open(`https://planmytimetable.vercel.app/?state=${encoded}`)
173 | .focus();
174 | close();
175 | } catch (e) {
176 | update(e);
177 | }
178 | };
179 |
180 | createWindow();
181 |
182 | // function nanoid from https://zelark.github.io/nano-id-cc/
183 | // Copyright 2017 Andrey Sitnik
184 |
185 | // Permission is hereby granted, free of charge, to any person obtaining a copy of
186 | // this software and associated documentation files (the "Software"), to deal in
187 | // the Software without restriction, including without limitation the rights to
188 | // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
189 | // the Software, and to permit persons to whom the Software is furnished to do so,
190 | // subject to the following conditions:
191 |
192 | // The above copyright notice and this permission notice shall be included in all
193 | // copies or substantial portions of the Software.
194 |
195 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
196 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
197 | // FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
198 | // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
199 | // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
200 | // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
201 |
202 | const nanoid = (t = 21) =>
203 | crypto
204 | .getRandomValues(new Uint8Array(t))
205 | .reduce(
206 | (t, e) =>
207 | (t +=
208 | (e &= 63) < 36
209 | ? e.toString(36)
210 | : e < 62
211 | ? (e - 26).toString(36).toUpperCase()
212 | : e > 62
213 | ? "-"
214 | : "_"),
215 | "",
216 | );
217 |
218 | // function JSONCrushSwap and Crush are from:
219 | // JSONCrush v1.1.6 by Frank Force - https://github.com/KilledByAPixel/JSONCrush
220 | // full credit to Frank Force for this wonderful package.
221 | //////////////////////////////////////////////////////////////////////////////////////////////////
222 | // MIT License
223 |
224 | // Copyright (c) 2019 Frank Force
225 |
226 | // Permission is hereby granted, free of charge, to any person obtaining a copy
227 | // of this software and associated documentation files (the "Software"), to deal
228 | // in the Software without restriction, including without limitation the rights
229 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
230 | // copies of the Software, and to permit persons to whom the Software is
231 | // furnished to do so, subject to the following conditions:
232 |
233 | // The above copyright notice and this permission notice shall be included in all
234 | // copies or substantial portions of the Software.
235 |
236 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
237 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
238 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
239 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
240 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
241 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
242 | // SOFTWARE.
243 |
244 | const JSONCrushSwap = (string, forward = 1) => {
245 | // swap out characters for lesser used ones that wont get escaped
246 | const swapGroups = [
247 | ['"', "'"],
248 | ["':", "!"],
249 | [",'", "~"],
250 | ["}", ")", "\\", "\\"],
251 | ["{", "(", "\\", "\\"],
252 | ];
253 |
254 | const swapInternal = (string, g) => {
255 | let regex = new RegExp(
256 | `${(g[2] ? g[2] : "") + g[0]}|${(g[3] ? g[3] : "") + g[1]}`,
257 | "g",
258 | );
259 | return string.replace(regex, ($1) => ($1 === g[0] ? g[1] : g[0]));
260 | };
261 |
262 | // need to be able to swap characters in reverse direction for uncrush
263 | if (forward)
264 | for (let i = 0; i < swapGroups.length; ++i)
265 | string = swapInternal(string, swapGroups[i]);
266 | else
267 | for (let i = swapGroups.length; i--; )
268 | string = swapInternal(string, swapGroups[i]);
269 |
270 | return string;
271 | };
272 | const crush = (string, maxSubstringLength = 50) => {
273 | const delimiter = "\u0001"; // used to split parts of crushed string
274 | const JSCrush = (string, replaceCharacters) => {
275 | // JSCrush Algorithm (repleace repeated substrings with single characters)
276 | let replaceCharacterPos = replaceCharacters.length;
277 | let splitString = "";
278 |
279 | const ByteLength = (string) =>
280 | encodeURI(encodeURIComponent(string)).replace(/%../g, "i").length;
281 | const HasUnmatchedSurrogate = (string) => {
282 | // check ends of string for unmatched surrogate pairs
283 | let c1 = string.charCodeAt(0);
284 | let c2 = string.charCodeAt(string.length - 1);
285 | return (c1 >= 0xdc00 && c1 <= 0xdfff) || (c2 >= 0xd800 && c2 <= 0xdbff);
286 | };
287 |
288 | // count instances of substrings
289 | let substringCount = {};
290 | for (
291 | let substringLength = 2;
292 | substringLength < maxSubstringLength;
293 | substringLength++
294 | )
295 | for (let i = 0; i < string.length - substringLength; ++i) {
296 | let substring = string.substr(i, substringLength);
297 |
298 | // don't recount if already in list
299 | if (substringCount[substring]) continue;
300 |
301 | // prevent breaking up unmatched surrogates
302 | if (HasUnmatchedSurrogate(substring)) continue;
303 |
304 | // count how many times the substring appears
305 | let count = 1;
306 | for (
307 | let substringPos = string.indexOf(substring, i + substringLength);
308 | substringPos >= 0;
309 | ++count
310 | )
311 | substringPos = string.indexOf(
312 | substring,
313 | substringPos + substringLength,
314 | );
315 |
316 | // add to list if it appears multiple times
317 | if (count > 1) substringCount[substring] = count;
318 | }
319 |
320 | while (true) {
321 | // loop while string can be crushed more
322 | // get the next character that is not in the string
323 | for (
324 | ;
325 | replaceCharacterPos-- &&
326 | string.includes(replaceCharacters[replaceCharacterPos]);
327 |
328 | ) {}
329 | if (replaceCharacterPos < 0) break; // ran out of replacement characters
330 | let replaceCharacter = replaceCharacters[replaceCharacterPos];
331 |
332 | // find the longest substring to replace
333 | let bestSubstring;
334 | let bestLengthDelta = 0;
335 | let replaceByteLength = ByteLength(replaceCharacter);
336 | for (let substring in substringCount) {
337 | // calculate change in length of string if it substring was replaced
338 | let count = substringCount[substring];
339 | let lengthDelta =
340 | (count - 1) * ByteLength(substring) -
341 | (count + 1) * replaceByteLength;
342 | if (!splitString.length) lengthDelta -= ByteLength(delimiter); // include the delimiter length
343 | if (lengthDelta <= 0) delete substringCount[substring];
344 | else if (lengthDelta > bestLengthDelta) {
345 | bestSubstring = substring;
346 | bestLengthDelta = lengthDelta;
347 | }
348 | }
349 | if (!bestSubstring) break; // string can't be compressed further
350 |
351 | // create new string with the split character
352 | string =
353 | string.split(bestSubstring).join(replaceCharacter) +
354 | replaceCharacter +
355 | bestSubstring;
356 | splitString = replaceCharacter + splitString;
357 |
358 | // update substring count list after the replacement
359 | let newSubstringCount = {};
360 | for (let substring in substringCount) {
361 | // make a new substring with the replacement
362 | let newSubstring = substring
363 | .split(bestSubstring)
364 | .join(replaceCharacter);
365 |
366 | // count how many times the new substring appears
367 | let count = 0;
368 | for (let i = string.indexOf(newSubstring); i >= 0; ++count)
369 | i = string.indexOf(newSubstring, i + newSubstring.length);
370 |
371 | // add to list if it appears multiple times
372 | if (count > 1) newSubstringCount[newSubstring] = count;
373 | }
374 | substringCount = newSubstringCount;
375 | }
376 |
377 | return { a: string, b: splitString };
378 | };
379 |
380 | // create a string of replacement characters
381 | let characters = [];
382 |
383 | // prefer replacing with characters that will not be escaped by encodeURIComponent
384 | const unescapedCharacters = `-_.!~*'()`;
385 | for (let i = 127; --i; ) {
386 | if (
387 | (i >= 48 && i <= 57) || // 0-9
388 | (i >= 65 && i <= 90) || // A-Z
389 | (i >= 97 && i <= 122) || // a-z
390 | unescapedCharacters.includes(String.fromCharCode(i))
391 | )
392 | characters.push(String.fromCharCode(i));
393 | }
394 |
395 | // pick from extended set last
396 | for (let i = 32; i < 255; ++i) {
397 | let c = String.fromCharCode(i);
398 | if (c != "\\" && !characters.includes(c)) characters.unshift(c);
399 | }
400 |
401 | // remove delimiter if it is found in the string
402 | string = string.replace(new RegExp(delimiter, "g"), "");
403 |
404 | // swap out common json characters
405 | string = JSONCrushSwap(string);
406 |
407 | // crush with JS crush
408 | const crushed = JSCrush(string, characters);
409 |
410 | // insert delimiter between JSCrush parts
411 | let crushedString = crushed.a;
412 | if (crushed.b.length) crushedString += delimiter + crushed.b;
413 |
414 | // fix issues with some links not being recognized properly
415 | crushedString += "_";
416 |
417 | // return crushed string
418 | return crushedString;
419 | };
420 | })();
421 |
--------------------------------------------------------------------------------