18 |
19 |
20 |
22 |
23 |
24 |
3 |
37 |
38 |
39 |
114 |
115 |
--------------------------------------------------------------------------------
/src/options/Options.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
12 | {{ M.app_name_short }}
5 |{{ M.pomodoro_assistant }}
6 |7 | Chris Schmich 8 | {{ M.and }} 9 | {{ M.contributors }} 10 |
11 |
13 |
20 | {{ M.feedback }}
14 |-
15 |
- {{ M.write_a_review }} 16 |
- {{ M.report_an_issue }} 17 |
- {{ M.help_translate }} 18 |
21 |
29 | {{ M.view }}
22 |-
23 |
- {{ M.release_notes }} 24 |
- {{ M.source_code }} 25 |
- {{ M.attributions }} 26 |
- {{ M.license }} 27 |
30 |
35 | {{ M.version }}
31 |-
32 |
- {{ version }} 33 |
{{ M.disclaimer }}
36 |
3 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/src/Sounds.js:
--------------------------------------------------------------------------------
1 | import Chrome from './Chrome';
2 | import M from './Messages';
3 |
4 | function createNotificationSounds() {
5 | let sounds = [
6 | { name: M.tone, file: 'f62b45bc.mp3' },
7 | { name: M.digital_watch, file: 'be75f155.mp3' },
8 | { name: M.analog_alarm_clock, file: '0f034826.mp3' },
9 | { name: M.digital_alarm_clock, file: 'fee369b7.mp3' },
10 | { name: M.electronic_chime, file: '28d6b5be.mp3' },
11 | { name: M.gong_1, file: '8bce59b5.mp3' },
12 | { name: M.gong_2, file: '85cab25d.mp3' },
13 | { name: M.computer_magic, file: '5cf807ce.mp3' },
14 | { name: M.fire_pager, file: 'b38e515f.mp3' },
15 | { name: M.glass_ping, file: '2ed9509e.mp3' },
16 | { name: M.music_box, file: 'ebe7deb8.mp3' },
17 | { name: M.pin_drop, file: '2e13802a.mp3' },
18 | { name: M.robot_blip_1, file: 'bd50add0.mp3' },
19 | { name: M.robot_blip_2, file: '36e93c27.mp3' },
20 | { name: M.ship_bell, file: '9404f598.mp3' },
21 | { name: M.train_horn, file: '6a215611.mp3' },
22 | { name: M.bike_horn, file: '72312dd3.mp3' },
23 | { name: M.bell_ring, file: 'b10d75f2.mp3' },
24 | { name: M.reception_bell, file: '54b867f9.mp3' },
25 | { name: M.toaster_oven, file: 'a258e906.mp3' },
26 | { name: M.battle_horn, file: '88736c22.mp3' },
27 | { name: M.ding, file: '1a5066bd.mp3' },
28 | { name: M.dong, file: '5e122cee.mp3' },
29 | { name: M.ding_dong, file: '92ff2a8a.mp3' },
30 | { name: M.airplane, file: '72cb1b7f.mp3' }
31 | ];
32 |
33 | for (let sound of sounds) {
34 | sound.file = `/audio/${sound.file}`;
35 | }
36 |
37 | return sounds;
38 | }
39 |
40 | function createTimerSounds() {
41 | let sounds = [
42 | { name: M.stopwatch, files: ['4cf03078.mp3', 'edab7b0d.mp3'] },
43 | { name: M.wristwatch, files: ['8dc834f8.mp3', '831a5549.mp3'] },
44 | { name: M.clock, files: ['af607ff1.mp3', 'fd23aaf3.mp3'] },
45 | { name: M.wall_clock, files: ['6103cd58.mp3', 'cad167ea.mp3'] },
46 | { name: M.desk_clock, files: ['6a981bfc.mp3', 'fd64de98.mp3'] },
47 | { name: M.wind_up_clock, files: ['bc4e3db2.mp3', 'f9efd11b.mp3'] },
48 | { name: M.antique_clock, files: ['875326f9.mp3', 'cba5f173.mp3'] },
49 | { name: M.small_clock, files: ['89dafd3e.mp3', '0a0ec499.mp3'] },
50 | { name: M.large_clock, files: ['2122d2a4.mp3', 'a273ba0c.mp3'] },
51 | { name: M.wood_block, files: ['ad6eac9e.mp3'] },
52 | { name: M.metronome, files: ['bced7c21.mp3', '9bd67f7e.mp3'] },
53 | { name: M.pulse, files: ['fe5d2a62.mp3'] }
54 | ];
55 |
56 | for (let sound of sounds) {
57 | sound.files = sound.files.map(file => `/audio/${file}`);
58 | }
59 |
60 | return sounds;
61 | }
62 |
63 | async function play(filename) {
64 | if (!filename) {
65 | return;
66 | }
67 |
68 | // We use AudioContext instead of Audio since it works more
69 | // reliably in different browsers (Chrome, FF, Brave).
70 | let context = new AudioContext();
71 |
72 | let source = context.createBufferSource();
73 | source.connect(context.destination);
74 | source.buffer = await new Promise(async (resolve, reject) => {
75 | let content = await Chrome.files.readBinary(filename);
76 | context.decodeAudioData(content, buffer => resolve(buffer), error => reject(error));
77 | });
78 |
79 | await new Promise(resolve => {
80 | // Cleanup audio context after sound plays.
81 | source.onended = () => {
82 | context.close();
83 | resolve();
84 | }
85 | source.start();
86 | });
87 | }
88 |
89 | const notification = createNotificationSounds();
90 | const timer = createTimerSounds();
91 |
92 | export {
93 | notification,
94 | timer,
95 | play
96 | };
--------------------------------------------------------------------------------
/src/options/CountdownSettings.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
16 |
5 |
15 |
6 | 
7 |
9 |
14 |
7 | {{ M.marinara_pomodoro_assistant }}
8 |
17 |
25 |
3 |
54 |
55 |
56 |
--------------------------------------------------------------------------------
/CONTRIBUTORS.md:
--------------------------------------------------------------------------------
1 | # Marinara: Contributors
2 |
3 | Marinara is open source software and is built by volunteers from around the world.
4 |
5 | - [Chris Schmich](https://github.com/schmich): Lead development & design
6 | - [Dmitry Muravyev](https://github.com/dimuravyev): Notification enhancements
7 | - [Mark Bennett](https://github.com/MarkBennett): Firefox compatibility
8 | - [José Varela](https://github.com/joselcvarela): Portuguese (Portugal) translation
9 | - [Omar Francisco](https://github.com/ofou): Spanish translation
10 | - [Maite Clausell](https://github.com/mcmtradu): Spanish translation
11 | - [Mathieu Lescaudron](https://github.com/MLescaudron): French translation
12 | - [Nicolai Hoilund](https://github.com/nicolaihoilund): Danish translation
13 | - [Jeroen Deviaene](https://github.com/jerodev): Dutch translation
14 | - [Robin Haveneers](https://github.com/haveneersrobin): Dutch translation
15 | - [Alex Olson](https://github.com/alexkolson): German translation
16 | - [William Killerud](https://github.com/wkillerud): Norwegian Bokmål translation
17 | - [Lambis Elef](https://github.com/lambiselef): Greek translation
18 | - [Ashraful Haq Rahat](https://github.com/MAHRahat): Bengali translation
19 | - [XTacDK](https://github.com/XTacDK): Polish translation
20 | - [lena15n](https://github.com/lena15n): Russian translation
21 | - [Po Chun, Lu](https://github.com/Sirius207): Chinese (Taiwan) translation
22 | - [Omega Chiu](https://github.com/omeganc): Chinese (Taiwan) translation
23 | - [Kietzmann](https://github.com/Kietzmann): Ukrainian translation
24 | - [Shashank SVRSN](https://github.com/fossterer): Telugu translation
25 | - [frozzie](https://github.com/frozzie): Chinese (China) translation
26 | - [myTimeGone](https://github.com/myTimeGone): Chinese (China) translation
27 | - [Julianna Brandão](https://github.com/JuhBass): Portuguese (Brazil) translation
28 | - [Teerapong Chantakard](https://github.com/azygous13): Thai translation
29 | - [Sarp Başaraner](https://github.com/sgbasaraner): Turkish translation
30 | - [L1Q](https://github.com/L1Q): Russian translation
31 | - [Maite Clausell](https://github.com/mcmtradu): Catalan translation
32 | - [Craig Loftus](https://github.com/craigloftus): Autostart timers
33 | - [Mathias Mikkelsen](https://github.com/Fysikeren): Danish translation
34 | - [Giovanni Pessiva](https://github.com/giovannipessiva): Italian translation
35 | - [TomG777](https://github.com/TomG777): Dutch translation
36 | - [João Pedro Sconetto](https://github.com/sconetto): Portuguese (Brazil) translation
37 | - [Ridho Pratama](https://github.com/ridho9): Indonesian translation
38 | - [Ivan Nesic](https://github.com/fatkaratekid): Serbian translation
39 | - [Duc Trinh](https://github.com/dmtri): Vietnamese translation
40 | - [Markus Deibel](https://github.com/msdeibel): German translation
41 | - [Pyrox](https://github.com/Pyr0x1): Italian translation
42 | - [kbigwheel](https://github.com/bigwheel): Japanese translation
43 | - [André Laszlo](https://github.com/andrelaszlo): Swedish translation
44 | - [Jaroslav Svoboda](https://github.com/multiflexi): Czech translation
45 | - [David Bautista](https://github.com/dbautistav): Notification Tab enhancement
46 | - [Baptiste Jacquemet](https://github.com/bjacquemet): French Translation
47 | - [Valentina De Col](https://github.com/valentinadc): Italian translation
48 | - [Ma Xiaoliang](https://github.com/ma-xiao-liang): Update Chinese(China) Translation
49 | - [Pooria Morovati](https://github.com/pooriamo): Persian translation
50 | - [Esko Rikkonen](https://github.com/eskorikkonen): Finnish translation
51 | - [Darkpingouin](https://github.com/Darkpingouin): French translation
52 | - [Faisal] (https://github.com/tr0id): Arabic translation
53 | - [rootEnginear](https://github.com/rootEnginear): Thai translation
54 | - [Federico Matteoni](https://github.com/fexed): Italian translation
55 | - [Iosif Dan](https://github.com/danutiosif): Romanian translation
56 | - [Brian L](https://github.com/brianl9995): Spanish translation
57 | - [Wesley Matos](https://github.com/wricke): Portuguese (Brazil) translation
58 | - [Rachel Ng](https://github.com/rachelnml): Malay translation
59 |
--------------------------------------------------------------------------------
/src/options/DayDistribution.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/src/background/Services.js:
--------------------------------------------------------------------------------
1 | import * as Sounds from '../Sounds';
2 | import { Service } from '../Service';
3 | import { SingletonPage, PageHost } from './SingletonPage';
4 |
5 | class SettingsService extends Service
6 | {
7 | constructor(settingsManager) {
8 | super();
9 | this.settingsManager = settingsManager;
10 | }
11 |
12 | async getSettings() {
13 | return await this.settingsManager.get();
14 | }
15 |
16 | async setSettings(settings) {
17 | if (!this._isValid(settings)) {
18 | return;
19 | }
20 |
21 | await this.settingsManager.set(settings);
22 | }
23 |
24 | _isValid(settings) {
25 | let phasesValid = [settings.focus, settings.shortBreak, settings.longBreak].every(this._isPhaseValid);
26 | if (!phasesValid) {
27 | return false;
28 | }
29 |
30 | let autostart = settings.autostart && settings.autostart.time;
31 | if (autostart && !autostart.match(/^\d+:\d+$/)) {
32 | return false;
33 | }
34 |
35 | return true;
36 | }
37 |
38 | _isPhaseValid(phase) {
39 | let { duration, timerSound, countdown } = phase;
40 | if (isNaN(duration) || duration <= 0 || duration > 999) {
41 | return false;
42 | }
43 |
44 | if (timerSound && timerSound.metronome) {
45 | let { bpm } = timerSound.metronome;
46 | if (isNaN(bpm) || bpm <= 0 || bpm > 1000) {
47 | return false;
48 | }
49 | }
50 |
51 | if (countdown.host === 'window') {
52 | let { resolution } = countdown;
53 |
54 | // Resolution must either be 'fullscreen' or a [width, height] array.
55 | let isValid = (resolution === 'fullscreen') || (Array.isArray(resolution) && resolution.length === 2 && resolution.every(Number.isInteger));
56 | if (!isValid) {
57 | return false;
58 | }
59 | }
60 |
61 | return true;
62 | }
63 | }
64 |
65 | class HistoryService extends Service
66 | {
67 | constructor(history) {
68 | super();
69 | this.history = history;
70 | }
71 |
72 | async getStats(since) {
73 | return await this.history.stats(since);
74 | }
75 |
76 | async getCSV() {
77 | return await this.history.toCSV();
78 | }
79 |
80 | async getAll() {
81 | return await this.history.all();
82 | }
83 |
84 | async merge(history) {
85 | return await this.history.merge(history);
86 | }
87 |
88 | async clearHistory() {
89 | return await this.history.clear();
90 | }
91 | }
92 |
93 | class PomodoroService extends Service
94 | {
95 | constructor(timer) {
96 | super();
97 | this.timer = timer;
98 | this.timer.observe(this);
99 | }
100 |
101 | async start() {
102 | this.timer.start();
103 | }
104 |
105 | async pause() {
106 | this.timer.pause();
107 | }
108 |
109 | async resume() {
110 | this.timer.resume();
111 | }
112 |
113 | async restart() {
114 | this.timer.restart();
115 | }
116 |
117 | async getStatus() {
118 | return this.timer.status;
119 | }
120 |
121 | onStart(...args) {
122 | this.emit('start', ...args);
123 | }
124 |
125 | onStop(...args) {
126 | this.emit('stop', ...args);
127 | }
128 |
129 | onPause(...args) {
130 | this.emit('pause', ...args);
131 | }
132 |
133 | onResume(...args) {
134 | this.emit('resume', ...args);
135 | }
136 |
137 | onTick(...args) {
138 | this.emit('tick', ...args);
139 | }
140 |
141 | onExpire(...args) {
142 | this.emit('expire', ...args);
143 | }
144 | }
145 |
146 | class SoundsService extends Service
147 | {
148 | async getNotificationSounds() {
149 | return Sounds.notification;
150 | }
151 |
152 | async getTimerSounds() {
153 | return Sounds.timer;
154 | }
155 | }
156 |
157 | class OptionsService extends Service
158 | {
159 | async showPage(optionPage) {
160 | let manifest = chrome.runtime.getManifest();
161 | let url = chrome.extension.getURL(manifest.options_page + '#/' + optionPage);
162 | let page = await SingletonPage.show(url, PageHost.Tab);
163 | page.focus();
164 | }
165 |
166 | async showSettingsPage() {
167 | return await this.showPage('settings');
168 | }
169 |
170 | async showHistoryPage() {
171 | return await this.showPage('history');
172 | }
173 |
174 | async showFeedbackPage() {
175 | return await this.showPage('feedback');
176 | }
177 | }
178 |
179 | const SettingsClient = SettingsService.proxy;
180 | const HistoryClient = HistoryService.proxy;
181 | const PomodoroClient = PomodoroService.proxy;
182 | const SoundsClient = SoundsService.proxy;
183 | const OptionsClient = OptionsService.proxy;
184 |
185 | export {
186 | SettingsService,
187 | SettingsClient,
188 | HistoryService,
189 | HistoryClient,
190 | PomodoroService,
191 | PomodoroClient,
192 | SoundsService,
193 | SoundsClient,
194 | OptionsService,
195 | OptionsClient
196 | };
--------------------------------------------------------------------------------
/src/countdown/Timer.vue:
--------------------------------------------------------------------------------
1 |
2 | {{ M.countdown_timer }}
4 |
5 |
53 | 6 | 10 |
11 |12 | 16 |
17 |
24 |
25 | 18 | 22 |
23 |26 | 30 |
31 |
51 |
52 | 32 | 43 |
44 |45 | 49 |
50 |
3 |
7 |
29 |
30 |
31 |
32 |
112 |
113 |
--------------------------------------------------------------------------------
/src/expire/Expire.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
5 |
8 |
16 |
17 |
18 |
137 |
138 |
--------------------------------------------------------------------------------
/src/countdown/Countdown.vue:
--------------------------------------------------------------------------------
1 |
2 | {{ title }}
4 |{{ message }}
9 |
15 | 10 | 11 |
12 |{{ M.completed_today }}
13 | 14 |
3 |
24 |
25 |
26 |
107 |
108 |
--------------------------------------------------------------------------------
/src/Service.js:
--------------------------------------------------------------------------------
1 | import EventEmitter from 'events';
2 |
3 | class ServiceBroker
4 | {
5 | constructor() {
6 | this.services = {};
7 | chrome.runtime.onMessage.addListener(this.onMessage.bind(this));
8 | }
9 |
10 | static get instance() {
11 | if (!this._instance) {
12 | this._instance = new ServiceBroker();
13 | }
14 | return this._instance;
15 | }
16 |
17 | static register(service) {
18 | return this.instance.register(service);
19 | }
20 |
21 | static async invoke(call) {
22 | return await this.instance.invoke(call);
23 | }
24 |
25 | register(service) {
26 | this.services[service.constructor.name] = service;
27 | return service;
28 | }
29 |
30 | unregister(service) {
31 | delete this.services[service.constructor.name];
32 | return service;
33 | }
34 |
35 | async invoke({ serviceName, methodName, args }) {
36 | let service = this.services[serviceName];
37 | if (service) {
38 | if (service[methodName]) {
39 | // Service is defined in this context, call method directly.
40 | return await service[methodName](...args);
41 | } else {
42 | throw new Exception(`Invalid service request: ${serviceName}.${methodName}.`);
43 | }
44 | }
45 |
46 | // Service is defined in another context, use sendMessage to call it.
47 | return await new Promise((resolve, reject) => {
48 | let message = { serviceName, methodName, args };
49 | chrome.runtime.sendMessage(message, ({ result, error }) => {
50 | if (error !== undefined) {
51 | reject(error);
52 | } else {
53 | resolve(result);
54 | }
55 | });
56 | });
57 | }
58 |
59 | onMessage({ serviceName, methodName, args }, sender, respond) {
60 | let service = this.services[serviceName];
61 | if (!service || methodName === undefined) {
62 | // Service is not defined in this context, so we have nothing to do.
63 | return;
64 | }
65 |
66 | if (!service[methodName]) {
67 | respond({ error: `Invalid service request: ${serviceName}.${methodName}.` });
68 | return true;
69 | }
70 |
71 | (async () => {
72 | try {
73 | respond({ result: await service[methodName](...args) });
74 | } catch (e) {
75 | console.error(e);
76 | respond({ error: `${e}` });
77 | }
78 | })();
79 |
80 | return true;
81 | }
82 | }
83 |
84 | class ServiceProxy extends EventEmitter
85 | {
86 | constructor(serviceName) {
87 | super();
88 | this.serviceName = serviceName;
89 | this.listenerCount = 0;
90 |
91 | this.on('removeListener', () => {
92 | if (--this.listenerCount === 0) {
93 | chrome.runtime.onMessage.removeListener(this.onMessage);
94 | }
95 | });
96 |
97 | this.on('newListener', () => {
98 | if (++this.listenerCount === 1) {
99 | this.onMessage = this._onMessage.bind(this);
100 | chrome.runtime.onMessage.addListener(this.onMessage);
101 | }
102 | });
103 | }
104 |
105 | dispose() {
106 | this.removeAllListeners();
107 | chrome.runtime.onMessage.removeListener(this.onMessage);
108 | }
109 |
110 | get(target, prop, receiver) {
111 | if (this[prop]) {
112 | return this[prop];
113 | }
114 |
115 | const self = this;
116 | return async function() {
117 | const call = {
118 | serviceName: self.serviceName,
119 | methodName: prop,
120 | args: Array.from(arguments)
121 | };
122 | return await ServiceBroker.invoke(call);
123 | };
124 | }
125 |
126 | _onMessage({ serviceName, eventName, args }, sender, respond) {
127 | if (serviceName !== this.serviceName || eventName === undefined) {
128 | return;
129 | }
130 |
131 | this.emit(eventName, ...args);
132 | }
133 | }
134 |
135 | class Service
136 | {
137 | constructor() {
138 | this.clients = {};
139 | this.serviceName = this.constructor.name;
140 | }
141 |
142 | emit(eventName, ...args) {
143 | chrome.runtime.sendMessage({
144 | serviceName: this.serviceName,
145 | eventName,
146 | args
147 | });
148 | }
149 |
150 | static get proxy() {
151 | const serviceName = this.name;
152 | const create = () => new Proxy(function() {}, new ServiceProxy(serviceName));
153 |
154 | const handler = {
155 | construct(target, args) {
156 | return create();
157 | },
158 | get(target, prop, receiver) {
159 | // Support one-shot service invocations.
160 | // This creates a client, performs the RPC, then cleans up.
161 | // Example usage: let result = await SomeClient.once.doThing('abc', 123);
162 |
163 | if (prop !== 'once') {
164 | return undefined;
165 | }
166 |
167 | return new Proxy(function() {}, {
168 | get(target, prop, receiver) {
169 | return (...args) => {
170 | let client = create();
171 | try {
172 | return client[prop](...args);
173 | } finally {
174 | client.dispose();
175 | }
176 | };
177 | }
178 | });
179 | }
180 | };
181 |
182 | return new Proxy(function() {}, handler);
183 | }
184 | }
185 |
186 | export {
187 | Service,
188 | ServiceBroker
189 | };
--------------------------------------------------------------------------------
/package/images/settings.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
88 |
--------------------------------------------------------------------------------
/src/options/Heatmap.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
32 |
33 |
218 |
--------------------------------------------------------------------------------
/src/background/Settings.js:
--------------------------------------------------------------------------------
1 | // Deep clone an object. Assumes only simple types and array/object aggregates of simple types.
2 | function clone(obj) {
3 | if (obj instanceof Array) {
4 | let copy = [];
5 | for (let el of obj) {
6 | copy.push(clone(el));
7 | }
8 | return copy;
9 | } else if (obj instanceof Object) {
10 | let copy = {};
11 | for (let prop in obj) {
12 | copy[prop] = clone(obj[prop]);
13 | }
14 | return copy;
15 | } else {
16 | return obj;
17 | }
18 | }
19 |
20 | class SettingsSchema
21 | {
22 | get version() {
23 | return 7;
24 | }
25 |
26 | get default() {
27 | return {
28 | focus: {
29 | duration: 25,
30 | timerSound: null,
31 | countdown: {
32 | host: null,
33 | autoclose: true,
34 | resolution: [500, 500]
35 | },
36 | notifications: {
37 | desktop: true,
38 | tab: true,
39 | sound: null
40 | }
41 | },
42 | shortBreak: {
43 | duration: 5,
44 | timerSound: null,
45 | countdown: {
46 | host: null,
47 | autoclose: true,
48 | resolution: [500, 500]
49 | },
50 | notifications: {
51 | desktop: true,
52 | tab: true,
53 | sound: null
54 | }
55 | },
56 | longBreak: {
57 | duration: 15,
58 | interval: 4,
59 | timerSound: null,
60 | countdown: {
61 | host: null,
62 | autoclose: true,
63 | resolution: [500, 500]
64 | },
65 | notifications: {
66 | desktop: true,
67 | tab: true,
68 | sound: null
69 | }
70 | },
71 | autostart: {
72 | time: null,
73 | },
74 | version: this.version
75 | };
76 | }
77 |
78 | from1To2(v1) {
79 | return {
80 | focus: {
81 | duration: v1.focus.duration,
82 | notifications: {
83 | desktop: v1.focus.desktopNotification,
84 | tab: v1.focus.newTabNotification,
85 | sound: v1.focus.sound ? new URL(v1.focus.sound).pathname : null
86 | }
87 | },
88 | shortBreak: {
89 | duration: v1.break.duration,
90 | notifications: {
91 | desktop: v1.break.desktopNotification,
92 | tab: v1.break.newTabNotification,
93 | sound: v1.break.sound ? new URL(v1.break.sound).pathname : null
94 | }
95 | },
96 | longBreak: {
97 | duration: 15,
98 | interval: 4,
99 | notifications: {
100 | desktop: v1.break.desktopNotification,
101 | tab: v1.break.newTabNotification,
102 | sound: v1.break.sound ? new URL(v1.break.sound).pathname : null
103 | }
104 | },
105 | version: 2
106 | };
107 | }
108 |
109 | from2To3(v2) {
110 | const fileNameMap = {
111 | '/audio/battle-horn.mp3': '/audio/88736c22.mp3',
112 | '/audio/bell-ring.mp3': '/audio/b10d75f2.mp3',
113 | '/audio/bike-horn.mp3': '/audio/72312dd3.mp3',
114 | '/audio/computer-magic.mp3': '/audio/5cf807ce.mp3',
115 | '/audio/din-ding.mp3': '/audio/72cb1b7f.mp3',
116 | '/audio/ding-dong.mp3': '/audio/92ff2a8a.mp3',
117 | '/audio/ding.mp3': '/audio/1a5066bd.mp3',
118 | '/audio/dong.mp3': '/audio/5e122cee.mp3',
119 | '/audio/electronic-chime.mp3': '/audio/28d6b5be.mp3',
120 | '/audio/fire-pager.mp3': '/audio/b38e515f.mp3',
121 | '/audio/glass-ping.mp3': '/audio/2ed9509e.mp3',
122 | '/audio/gong-1.mp3': '/audio/8bce59b5.mp3',
123 | '/audio/gong-2.mp3': '/audio/85cab25d.mp3',
124 | '/audio/music-box.mp3': '/audio/ebe7deb8.mp3',
125 | '/audio/pin-dropping.mp3': '/audio/2e13802a.mp3',
126 | '/audio/reception-bell.mp3': '/audio/54b867f9.mp3',
127 | '/audio/robot-blip-1.mp3': '/audio/bd50add0.mp3',
128 | '/audio/robot-blip-2.mp3': '/audio/36e93c27.mp3',
129 | '/audio/ship-bell.mp3': '/audio/9404f598.mp3',
130 | '/audio/toaster-oven.mp3': '/audio/a258e906.mp3',
131 | '/audio/tone.mp3': '/audio/f62b45bc.mp3',
132 | '/audio/train-horn.mp3': '/audio/6a215611.mp3'
133 | };
134 |
135 | let v3 = clone(v2);
136 | v3.version = 3;
137 |
138 | for (let group of [v3.focus, v3.shortBreak, v3.longBreak].map(s => s.notifications)) {
139 | if (group.sound) {
140 | let newName = fileNameMap[group.sound.toLowerCase()];
141 | group.sound = newName || group.sound;
142 | }
143 | }
144 |
145 | return v3;
146 | }
147 |
148 | from3To4(v3) {
149 | let v4 = clone(v3);
150 | v4.version = 4;
151 |
152 | v4.focus.timerSound = null;
153 | v4.shortBreak.timerSound = null;
154 | v4.longBreak.timerSound = null;
155 |
156 | return v4;
157 | }
158 |
159 | from4To5(v4) {
160 | let v5 = clone(v4);
161 | v5.version = 5;
162 |
163 | v5.autostart = {
164 | time: null
165 | };
166 |
167 | return v5;
168 | }
169 |
170 | from5To6(v5) {
171 | let v6 = clone(v5);
172 | v6.version = 6;
173 |
174 | if (v6.focus.timerSound) {
175 | v6.focus.timerSound = {
176 | metronome: v6.focus.timerSound
177 | };
178 | }
179 |
180 | return v6;
181 | }
182 |
183 | from6To7(v6) {
184 | let v7 = clone(v6);
185 | v7.version = 7;
186 |
187 | v7.focus.countdown = {
188 | host: null,
189 | autoclose: true,
190 | resolution: [500, 500]
191 | };
192 |
193 | v7.shortBreak.countdown = {
194 | host: null,
195 | autoclose: true,
196 | resolution: [500, 500]
197 | };
198 |
199 | v7.longBreak.countdown = {
200 | host: null,
201 | autoclose: true,
202 | resolution: [500, 500]
203 | };
204 |
205 | return v7;
206 | }
207 | }
208 |
209 | class PersistentSettings
210 | {
211 | static async create(settingsManager) {
212 | let settings = await settingsManager.get();
213 |
214 | // When the settings change, we update the underlying settigs object, which
215 | // allows users of the settings to see the updated values.
216 | settingsManager.on('change', newSettings => settings = newSettings);
217 |
218 | // We return a proxy object that forwards all getters
219 | // to the underlying settings object.
220 | return new Proxy(function() {}, {
221 | get(target, prop, receiver) {
222 | return settings[prop];
223 | }
224 | });
225 | }
226 | }
227 |
228 | export {
229 | SettingsSchema,
230 | PersistentSettings
231 | };
--------------------------------------------------------------------------------
/assets/promotional/hacktoberfest.svg:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/src/Chrome.js:
--------------------------------------------------------------------------------
1 | class ChromeError extends Error
2 | {
3 | constructor(...params) {
4 | super(...params);
5 | }
6 | }
7 |
8 | class Chrome
9 | {
10 | static get tabs() {
11 | return Tabs;
12 | }
13 |
14 | static get windows() {
15 | return Windows;
16 | }
17 |
18 | static get notifications() {
19 | return Notifications;
20 | }
21 |
22 | static get storage() {
23 | return Storage;
24 | }
25 |
26 | static get files() {
27 | return Files;
28 | }
29 |
30 | static get alarms() {
31 | return Alarms;
32 | }
33 |
34 | static get runtime() {
35 | return Runtime;
36 | }
37 | }
38 |
39 | function promise(fn) {
40 | return new Promise((resolve, reject) => {
41 | const callback = (...results) => {
42 | const err = chrome.runtime.lastError;
43 | if (err) {
44 | reject(new ChromeError(err.message));
45 | } else {
46 | resolve(...results);
47 | }
48 | };
49 |
50 | fn(callback);
51 | });
52 | }
53 |
54 | class Tabs
55 | {
56 | static async create(options) {
57 | // Create tab in specific window.
58 | const createInWindow = async windowId => {
59 | // Get the currently active tab in this window and make it the 'opener'
60 | // of the tab we're creating. When our tab is closed, the opener tab will
61 | // be reactivated.
62 | let tabs = await Chrome.tabs.query({ active: true, windowId });
63 | let openerTab = (tabs && tabs.length > 0) ? tabs[0] : {};
64 | let openerTabId = openerTab.id || null;
65 | let index = openerTab.index + 1 || 0;
66 |
67 | let tabOptions = { ...options, windowId, openerTabId, index };
68 | return promise(callback => {
69 | chrome.tabs.create(tabOptions, callback);
70 | });
71 | };
72 |
73 | try {
74 | let targetWindow = await Chrome.windows.getLastFocused({ windowTypes: ['normal'] });
75 | if (targetWindow) {
76 | return createInWindow(targetWindow.id);
77 | }
78 | } catch (e) {
79 | if (e instanceof ChromeError) {
80 | // We assume there was no last focused window, ignore.
81 | console.error(e);
82 | } else {
83 | throw e;
84 | }
85 | }
86 |
87 | // No active window for our tab, so we must create our own.
88 | let windowOptions = { focused: !!options.active };
89 | let newWindow = await Chrome.windows.create(windowOptions);
90 | return createInWindow(newWindow.id);
91 | }
92 |
93 | static async getCurrent() {
94 | return promise(callback => {
95 | chrome.tabs.getCurrent(callback);
96 | });
97 | }
98 |
99 | static async update(tabId, updateProperties) {
100 | return promise(callback => {
101 | chrome.tabs.update(tabId, updateProperties, callback);
102 | });
103 | }
104 |
105 | static async query(queryInfo) {
106 | return promise(callback => {
107 | chrome.tabs.query(queryInfo, callback);
108 | });
109 | }
110 | }
111 |
112 | class Windows
113 | {
114 | static async getAll(getInfo) {
115 | return promise(callback => {
116 | chrome.windows.getAll(getInfo, callback);
117 | });
118 | }
119 |
120 | static async getLastFocused(getInfo) {
121 | return promise(callback => {
122 | chrome.windows.getLastFocused(getInfo, callback);
123 | });
124 | }
125 |
126 | static async create(createData) {
127 | if (createData.state === 'maximized' && createData.type === 'popup') {
128 | let { os } = await Chrome.runtime.getPlatformInfo();
129 | if (os === chrome.runtime.PlatformOs.MAC) {
130 | // Bug workaround: On macOS, creating maximized popup windows is bugged
131 | // and creates really small windows instead. Here, we work around this
132 | // behavior by creating a window with its size equal to the screen size.
133 | createData = {
134 | ...createData,
135 | width: window.screen.width,
136 | height: window.screen.height,
137 | left: 0,
138 | top: 0
139 | };
140 | delete createData.state;
141 | }
142 | }
143 |
144 | return promise(callback => {
145 | chrome.windows.create(createData, callback);
146 | });
147 | }
148 |
149 | static async update(windowId, updateInfo) {
150 | return promise(callback => {
151 | chrome.windows.update(windowId, updateInfo, callback);
152 | });
153 | }
154 | }
155 |
156 | class Notifications
157 | {
158 | static async create(options) {
159 | return promise(callback => {
160 | try {
161 | chrome.notifications.create('', options, callback);
162 | } catch (e) {
163 | // This is failing on Firefox as it doesn't support the buttons option for the notification and raises an exception when this is called. (see http://bugzil.la/1190681)
164 | // Try again with a subset of options that are more broadly supported
165 | const compatibleOptions = {
166 | type: options.type,
167 | iconUrl: options.iconUrl,
168 | title: options.title,
169 | message: options.message
170 | };
171 | chrome.notifications.create('', compatibleOptions, callback);
172 | }
173 | });
174 | }
175 | }
176 |
177 | class Storage
178 | {
179 | constructor(store) {
180 | this.store = store;
181 | }
182 |
183 | get(keys = null) {
184 | return promise(callback => {
185 | this.store.get(keys, callback);
186 | });
187 | }
188 |
189 | set(obj) {
190 | return promise(callback => {
191 | this.store.set(obj, callback);
192 | });
193 | }
194 |
195 | clear() {
196 | return promise(callback => {
197 | this.store.clear(callback);
198 | });
199 | }
200 |
201 | static get sync() {
202 | if (!this._sync) {
203 | this._sync = new Storage(chrome.storage.sync);
204 | }
205 | return this._sync;
206 | }
207 |
208 | static get local() {
209 | if (!this._local) {
210 | this._local = new Storage(chrome.storage.local);
211 | }
212 | return this._local;
213 | }
214 | }
215 |
216 | class Files
217 | {
218 | static async readFile(file) {
219 | let url = chrome.runtime.getURL(file);
220 | let response = await fetch(url);
221 | return await response.text();
222 | }
223 |
224 | static async readBinary(file) {
225 | let url = chrome.runtime.getURL(file);
226 | let response = await fetch(url);
227 | return await response.arrayBuffer();
228 | }
229 | }
230 |
231 | class Alarms
232 | {
233 | static create(name, alarmInfo) {
234 | return chrome.alarms.create(name, alarmInfo);
235 | }
236 |
237 | static async clearAll() {
238 | return promise(callback => {
239 | chrome.alarms.clearAll(callback)
240 | });
241 | }
242 | }
243 |
244 | class Runtime
245 | {
246 | static getPlatformInfo() {
247 | return promise(callback => {
248 | chrome.runtime.getPlatformInfo(callback)
249 | });
250 | }
251 | }
252 |
253 | export default Chrome;
254 |
--------------------------------------------------------------------------------
/src/background/Menu.js:
--------------------------------------------------------------------------------
1 | import M from '../Messages';
2 | import { OptionsClient } from './Services';
3 |
4 | class Menu
5 | {
6 | constructor(contexts, ...groups) {
7 | this.contexts = contexts;
8 | this.groups = groups;
9 | }
10 |
11 | addGroup(group) {
12 | this.groups.push(group);
13 | }
14 |
15 | apply() {
16 | chrome.contextMenus.removeAll();
17 |
18 | let firstGroup = true;
19 | for (let group of this.groups) {
20 | let firstItem = true;
21 | for (let item of group.items) {
22 | if (!item.visible) {
23 | continue;
24 | }
25 |
26 | if (firstItem && !firstGroup) {
27 | chrome.contextMenus.create({ type: 'separator', contexts: this.contexts });
28 | }
29 |
30 | firstGroup = false;
31 | firstItem = false;
32 |
33 | if (item instanceof ParentMenu) {
34 | let id = chrome.contextMenus.create({
35 | title: item.title,
36 | contexts: this.contexts
37 | });
38 |
39 | for (let child of item.children) {
40 | if (!child.visible) {
41 | continue;
42 | }
43 |
44 | chrome.contextMenus.create({
45 | title: child.title,
46 | contexts: this.contexts,
47 | onclick: () => child.run(),
48 | parentId: id
49 | });
50 | }
51 | } else {
52 | chrome.contextMenus.create({
53 | title: item.title,
54 | contexts: this.contexts,
55 | onclick: () => item.run()
56 | });
57 | }
58 | }
59 | }
60 | }
61 | }
62 |
63 | class MenuGroup
64 | {
65 | constructor(...items) {
66 | this.items = items;
67 | }
68 |
69 | addItem(item) {
70 | this.items.push(item);
71 | }
72 | }
73 |
74 | class ParentMenu
75 | {
76 | constructor(...children) {
77 | this.children = children;
78 | }
79 |
80 | addChild(child) {
81 | this.children.push(child);
82 | }
83 |
84 | get title() {
85 | return '';
86 | }
87 |
88 | get visible() {
89 | return false;
90 | }
91 | }
92 |
93 | class RestartTimerParentMenu extends ParentMenu
94 | {
95 | constructor(...children) {
96 | super(...children);
97 | }
98 |
99 | get title() {
100 | return M.restart_timer;
101 | }
102 |
103 | get visible() {
104 | return true;
105 | }
106 | }
107 |
108 | class Action
109 | {
110 | get title() {
111 | return '';
112 | }
113 |
114 | get visible() {
115 | return false;
116 | }
117 |
118 | run() {
119 | }
120 | }
121 |
122 | class StartFocusingAction extends Action
123 | {
124 | constructor(timer) {
125 | super();
126 | this.timer = timer;
127 | }
128 |
129 | get title() {
130 | return M.start_focusing;
131 | }
132 |
133 | get visible() {
134 | return true;
135 | }
136 |
137 | run() {
138 | this.timer.startFocus();
139 | }
140 | }
141 |
142 | class StartShortBreakAction extends Action
143 | {
144 | constructor(timer) {
145 | super();
146 | this.timer = timer;
147 | }
148 |
149 | get title() {
150 | return this.timer.hasLongBreak ? M.start_short_break : M.start_break;
151 | }
152 |
153 | get visible() {
154 | return true;
155 | }
156 |
157 | run() {
158 | this.timer.startShortBreak();
159 | }
160 | }
161 |
162 | class StartLongBreakAction extends Action
163 | {
164 | constructor(timer) {
165 | super();
166 | this.timer = timer;
167 | }
168 |
169 | get title() {
170 | return M.start_long_break;
171 | }
172 |
173 | get visible() {
174 | return this.timer.hasLongBreak;
175 | }
176 |
177 | run() {
178 | this.timer.startLongBreak();
179 | }
180 | }
181 |
182 | class StopTimerAction extends Action
183 | {
184 | constructor(timer) {
185 | super();
186 | this.timer = timer;
187 | }
188 |
189 | get title() {
190 | return M.stop_timer;
191 | }
192 |
193 | get visible() {
194 | return this.timer.isRunning || this.timer.isPaused;
195 | }
196 |
197 | run() {
198 | this.timer.stop();
199 | }
200 | }
201 |
202 | class PauseTimerAction extends Action
203 | {
204 | constructor(timer) {
205 | super();
206 | this.timer = timer;
207 | }
208 |
209 | get title() {
210 | return M.pause_timer;
211 | }
212 |
213 | get visible() {
214 | return this.timer.isRunning;
215 | }
216 |
217 | run() {
218 | this.timer.pause();
219 | }
220 | }
221 |
222 | class ResumeTimerAction extends Action
223 | {
224 | constructor(timer) {
225 | super();
226 | this.timer = timer;
227 | }
228 |
229 | get title() {
230 | return M.resume_timer;
231 | }
232 |
233 | get visible() {
234 | return this.timer.isPaused;
235 | }
236 |
237 | run() {
238 | this.timer.resume();
239 | }
240 | }
241 |
242 | class PomodoroHistoryAction extends Action
243 | {
244 | constructor() {
245 | super();
246 | }
247 |
248 | get title() {
249 | return M.pomodoro_history;
250 | }
251 |
252 | get visible() {
253 | return true;
254 | }
255 |
256 | async run() {
257 | await OptionsClient.once.showHistoryPage();
258 | }
259 | }
260 |
261 | class StartPomodoroCycleAction extends Action
262 | {
263 | constructor(timer) {
264 | super();
265 | this.timer = timer;
266 | }
267 |
268 | get title() {
269 | if (this.timer.isRunning || this.timer.isPaused) {
270 | return M.restart_pomodoro_cycle;
271 | } else {
272 | return M.start_pomodoro_cycle;
273 | }
274 | }
275 |
276 | get visible() {
277 | return this.timer.hasLongBreak;
278 | }
279 |
280 | run() {
281 | this.timer.startCycle();
282 | }
283 | }
284 |
285 | class PomodoroMenuSelector
286 | {
287 | constructor(timer, inactive, active) {
288 | this.timer = timer;
289 | this.inactive = inactive;
290 | this.active = active;
291 | }
292 |
293 | apply() {
294 | let menu = (this.timer.isRunning || this.timer.isPaused) ? this.active : this.inactive;
295 | menu.apply();
296 | }
297 | }
298 |
299 | function createPomodoroMenu(timer) {
300 | let pause = new PauseTimerAction(timer);
301 | let resume = new ResumeTimerAction(timer);
302 | let stop = new StopTimerAction(timer);
303 |
304 | let startCycle = new StartPomodoroCycleAction(timer);
305 | let startFocus = new StartFocusingAction(timer);
306 | let startShortBreak = new StartShortBreakAction(timer);
307 | let startLongBreak = new StartLongBreakAction(timer);
308 | let viewHistory = new PomodoroHistoryAction();
309 |
310 | let inactive = new Menu(['browser_action'],
311 | new MenuGroup(
312 | startCycle,
313 | startFocus,
314 | startShortBreak,
315 | startLongBreak
316 | ),
317 | new MenuGroup(
318 | viewHistory
319 | )
320 | );
321 |
322 | let active = new Menu(['browser_action'],
323 | new MenuGroup(
324 | pause,
325 | resume,
326 | stop,
327 | new RestartTimerParentMenu(
328 | startFocus,
329 | startShortBreak,
330 | startLongBreak
331 | ),
332 | startCycle
333 | ),
334 | new MenuGroup(
335 | viewHistory
336 | )
337 | );
338 |
339 | return new PomodoroMenuSelector(timer, inactive, active);
340 | }
341 |
342 | export {
343 | createPomodoroMenu
344 | };
--------------------------------------------------------------------------------
/src/options/History.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
13 |
14 |
15 |
19 |
23 |
3 |
4 |
26 |
42 |
43 |
49 |
50 |
56 |
57 |
77 |
78 |
79 |
80 |
194 |
195 |
--------------------------------------------------------------------------------
/package/ATTRIBUTION:
--------------------------------------------------------------------------------
1 | File: audio/72312dd3.mp3
2 | Author: StickInTheMud
3 | URL: http://soundbible.com/1446-Bike-Horn.html
4 | License: Creative Commons Sampling Plus 1.0 (https://creativecommons.org/licenses/sampling+/1.0/)
5 |
6 | File: audio/6a215611.mp3
7 | Author: Mike Koenig
8 | URL: http://soundbible.com/1695-Train-Honk-Horn-2x.html
9 | License: Creative Commons Attribution 3.0 (https://creativecommons.org/licenses/by/3.0/us/)
10 |
11 | File: audio/28d6b5be.mp3
12 | Author: KevanGC
13 | URL: http://soundbible.com/1598-Electronic-Chime.html
14 | License: Public Domain
15 |
16 | File: audio/8bce59b5.mp3
17 | Author: Dianakc
18 | URL: http://soundbible.com/2062-Metal-Gong-1.html
19 | License: Creative Commons Attribution 3.0 (https://creativecommons.org/licenses/by/3.0/us/)
20 |
21 | File: audio/9404f598.mp3
22 | Author: Mike Koenig
23 | URL: http://soundbible.com/1746-Ship-Bell.html
24 | License: Creative Commons Attribution 3.0 (https://creativecommons.org/licenses/by/3.0/us/)
25 |
26 | File: audio/5cf807ce.mp3
27 | Author: Microsift
28 | URL: http://soundbible.com/1630-Computer-Magic.html
29 | License: Public Domain
30 |
31 | File: audio/ebe7deb8.mp3
32 | Author: Big Daddy
33 | URL: http://soundbible.com/1619-Music-Box.html
34 | License: Public Domain
35 |
36 | File: audio/2ed9509e.mp3
37 | Author: Go445
38 | URL: http://soundbible.com/2084-Glass-Ping.html
39 | License: Creative Commons Attribution-NonCommercial (https://creativecommons.org/licenses/by-nc/3.0/us/)
40 |
41 | File: audio/2e13802a.mp3
42 | Author: Brian Rocca
43 | URL: http://soundbible.com/1992-Pin-Dropping.html
44 | License: Creative Commons Attribution 3.0 (https://creativecommons.org/licenses/by/3.0/us/)
45 |
46 | File: audio/bd50add0.mp3
47 | Author: Marianne Gagnon
48 | URL: http://soundbible.com/1682-Robot-Blip.html
49 | License: Creative Commons Attribution 3.0 (https://creativecommons.org/licenses/by/3.0/us/)
50 |
51 | File: audio/36e93c27.mp3
52 | Author: Marianne Gagnon
53 | URL: http://soundbible.com/1669-Robot-Blip-2.html
54 | License: Creative Commons Attribution 3.0 (https://creativecommons.org/licenses/by/3.0/us/)
55 |
56 | File: audio/b38e515f.mp3
57 | Author: jason
58 | URL: http://soundbible.com/1766-Fire-Pager.html
59 | License: Public Domain
60 |
61 | File: audio/f62b45bc.mp3
62 | Author: His Self
63 | URL: http://soundbible.com/1815-A-Tone.html
64 | License: Public Domain
65 |
66 | File: audio/54b867f9.mp3
67 | Author: cdrk
68 | URL: https://www.freesound.org/people/cdrk/sounds/264594/
69 | License: Creative Commons Attribution 3.0 Unported (http://creativecommons.org/licenses/by/3.0/)
70 |
71 | File: audio/1a5066bd.mp3
72 | Author: Aiwha
73 | URL: https://www.freesound.org/people/Aiwha/sounds/196106/
74 | License: Creative Commons Attribution 3.0 Unported (http://creativecommons.org/licenses/by/3.0/)
75 |
76 | File: audio/a258e906.mp3
77 | Author: sethlind
78 | URL: https://www.freesound.org/people/sethlind/sounds/265012/
79 | License: Creative Commons Public Domain Dedication (http://creativecommons.org/publicdomain/zero/1.0/)
80 |
81 | File: audio/72cb1b7f.mp3
82 | Author: Daenn
83 | URL: https://www.freesound.org/people/Daenn/sounds/159158/
84 | License: Creative Commons Public Domain Dedication (http://creativecommons.org/publicdomain/zero/1.0/)
85 |
86 | File: audio/85cab25d.mp3
87 | Author: GowlerMusic
88 | URL: https://www.freesound.org/people/GowlerMusic/sounds/266566/
89 | License: Creative Commons Attribution 3.0 Unported (http://creativecommons.org/licenses/by/3.0/)
90 |
91 | File: audio/88736c22.mp3
92 | Author: freefire66
93 | URL: https://www.freesound.org/people/freefire66/sounds/175946/
94 | License: Creative Commons Public Domain Dedication (http://creativecommons.org/publicdomain/zero/1.0/)
95 |
96 | File: audio/5e122cee.mp3
97 | Author: Roentgine
98 | URL: https://www.freesound.org/people/Roentgine/sounds/74710/
99 | License: Creative Commons Attribution 3.0 Unported (http://creativecommons.org/licenses/by/3.0/)
100 |
101 | File: audio/92ff2a8a.mp3
102 | Author: jacobsteel
103 | URL: https://www.freesound.org/people/jacobsteel/sounds/243607/
104 | License: Creative Commons Attribution 3.0 Unported (http://creativecommons.org/licenses/by/3.0/)
105 |
106 | File: audio/0f034826.mp3
107 | Author: bone666138
108 | URL: http://freesound.org/people/bone666138/sounds/198841/
109 | License: Creative Commons Attribution 3.0 Unported (http://creativecommons.org/licenses/by/3.0/)
110 |
111 | File: audio/be75f155.mp3
112 | Author: Koyber
113 | URL: http://freesound.org/people/Koyber/sounds/160484/
114 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
115 |
116 | File: audio/fee369b7.mp3
117 | Author: AlaskaRobotics
118 | URL: http://freesound.org/people/AlaskaRobotics/sounds/221085/
119 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
120 |
121 | Files: audio/4cf03078.mp3, audio/edab7b0d.mp3
122 | Author: FoolBoyMedia
123 | URL: http://freesound.org/people/FoolBoyMedia/sounds/264498/
124 | License: Creative Commons Attribution-NonCommercial (https://creativecommons.org/licenses/by-nc/3.0/us/)
125 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
126 |
127 | Files: audio/af607ff1.mp3, audio/fd23aaf3.mp3
128 | Author: AntumDeluge
129 | URL: http://freesound.org/people/AntumDeluge/sounds/188033/
130 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
131 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
132 |
133 | File: audio/ad6eac9e.mp3
134 | Author: Druminfected
135 | URL: http://freesound.org/people/Druminfected/sounds/250552/
136 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
137 | Notes: The original audio was cropped and converted to mp3.
138 |
139 | File: fe5d2a62.mp3
140 | Author: Tobiasz 'unfa' Karoń
141 | URL: http://freesound.org/people/unfa/sounds/243749/
142 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
143 | Notes: The original audio was converted to mp3.
144 |
145 | Files: audio/bc4e3db2.mp3, audio/f9efd11b.mp3
146 | Author: FlashTrauma
147 | URL: http://freesound.org/people/FlashTrauma/sounds/398275/
148 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
149 | Notes: The original audio was denoised, split into separate tick/tock sounds, and converted to mp3.
150 |
151 | Files: audio/bced7c21.mp3, audio/9bd67f7e.mp3
152 | Author: HollowRiku
153 | URL: http://freesound.org/people/HollowRiku/sounds/146781/
154 | License: Creative Commons Attribution 3.0 Unported (https://creativecommons.org/licenses/by/3.0/)
155 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
156 |
157 | Files: audio/875326f9.mp3, audio/cba5f173.mp3
158 | Author: differentieel
159 | URL: http://freesound.org/people/differentieel/sounds/245455/
160 | License: Creative Commons Attribution-NonCommercial (https://creativecommons.org/licenses/by-nc/3.0/us/)
161 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
162 |
163 | Files: audio/6a981bfc.mp3, audio/fd64de98.mp3
164 | Author: InspectorJ
165 | URL: http://freesound.org/people/InspectorJ/sounds/343130/
166 | License: Creative Commons Attribution 3.0 Unported (https://creativecommons.org/licenses/by/3.0/)
167 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
168 |
169 | Files: audio/8dc834f8.mp3, audio/831a5549.mp3
170 | Author: andychristen
171 | URL: http://freesound.org/people/andychristen/sounds/268185/
172 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
173 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
174 |
175 | Files: audio/2122d2a4.mp3, audio/a273ba0c.mp3
176 | Author: Rollo145
177 | URL: http://freesound.org/people/Rollo145/sounds/256477/
178 | License: Creative Commons Attribution 3.0 Unported (https://creativecommons.org/licenses/by/3.0/)
179 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
180 |
181 | Files: audio/6103cd58.mp3, audio/cad167ea.mp3
182 | Author: atka187
183 | URL: http://freesound.org/people/atka187/sounds/409091/
184 | License: Creative Commons 0 1.0 Universal Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)
185 | Notes: The original audio was split into separate tick/tock sounds and converted to mp3.
186 |
187 | File: images/settings.svg
188 | Author: Freepik
189 | URL: https://www.flaticon.com/free-icon/settings_263100
190 | License: Flaticon Basic License (https://file000.flaticon.com/downloads/license/license.pdf)
191 |
192 | File: images/history.svg
193 | Author: Lucy G
194 | URL: https://www.flaticon.com/free-icon/stats_118798
195 | License: Creative Commons Attribution 3.0 Unported (https://creativecommons.org/licenses/by/3.0/)
196 |
197 | File: images/pause.svg
198 | Author: Chanut
199 | URL: https://www.flaticon.com/free-icon/pause_151859
200 | License: Flaticon Basic License (https://file000.flaticon.com/downloads/license/license.pdf)
201 |
202 | File: images/play.svg
203 | Author: Chanut
204 | URL: https://www.flaticon.com/free-icon/play-button_151860
205 | License: Flaticon Basic License (https://file000.flaticon.com/downloads/license/license.pdf)
206 |
207 | File: images/restart.svg
208 | Author: Freepik
209 | URL: https://www.flaticon.com/free-icon/undo-circular-arrow_44426
210 | License: Flaticon Basic License (https://file000.flaticon.com/downloads/license/license.pdf)
--------------------------------------------------------------------------------
/src/background/Timer.js:
--------------------------------------------------------------------------------
1 | import Enum from './Enum';
2 | import EventEmitter from 'events';
3 |
4 | const TimerState = new Enum({
5 | Stopped: 0,
6 | Running: 1,
7 | Paused: 2
8 | });
9 |
10 | class Timer extends EventEmitter
11 | {
12 | constructor(duration, tick) {
13 | super();
14 |
15 | this.state = TimerState.Stopped;
16 | this.duration = duration;
17 | this.tick = tick;
18 |
19 | this.tickInterval = null;
20 | this.expireTimeout = null;
21 |
22 | this.checkpointStartAt = null;
23 | this.checkpointElapsed = 0;
24 | }
25 |
26 | observe(observer) {
27 | observer.onStart && this.on('start', (...args) => observer.onStart(...args));
28 | observer.onStop && this.on('stop', (...args) => observer.onStop(...args));
29 | observer.onPause && this.on('pause', (...args) => observer.onPause(...args));
30 | observer.onResume && this.on('resume', (...args) => observer.onResume(...args));
31 | observer.onTick && this.on('tick', (...args) => observer.onTick(...args));
32 | observer.onExpire && this.on('expire', (...args) => observer.onExpire(...args));
33 | }
34 |
35 | get isStopped() {
36 | return this.state === TimerState.Stopped;
37 | }
38 |
39 | get isRunning() {
40 | return this.state === TimerState.Running;
41 | }
42 |
43 | get isPaused() {
44 | return this.state === TimerState.Paused;
45 | }
46 |
47 | get remaining() {
48 | return this.duration - this.elapsed;
49 | }
50 |
51 | get elapsed() {
52 | let periodElapsed = 0;
53 | if (this.checkpointStartAt && this.isRunning) {
54 | periodElapsed = (Date.now() - this.checkpointStartAt) / 1000;
55 | }
56 | return this.checkpointElapsed + periodElapsed;
57 | }
58 |
59 | get status() {
60 | return {
61 | state: this.state,
62 | duration: this.duration,
63 | elapsed: this.elapsed,
64 | remaining: this.remaining,
65 | checkpointElapsed: this.checkpointElapsed,
66 | checkpointStartAt: this.checkpointStartAt
67 | };
68 | }
69 |
70 | start() {
71 | if (!this.isStopped) {
72 | return;
73 | }
74 |
75 | this.setExpireTimeout(this.duration);
76 | this.setTickInterval(this.tick);
77 |
78 | this.state = TimerState.Running;
79 | this.checkpointStartAt = Date.now();
80 |
81 | this.emit('start', this.status);
82 | }
83 |
84 | stop() {
85 | if (this.isStopped) {
86 | return;
87 | }
88 |
89 | clearInterval(this.tickInterval);
90 | clearTimeout(this.expireTimeout);
91 |
92 | this.tickInterval = null;
93 | this.expireTimeout = null;
94 | this.checkpointStartAt = null;
95 | this.checkpointElapsed = 0;
96 |
97 | this.state = TimerState.Stopped;
98 |
99 | this.emit('stop', this.status);
100 | }
101 |
102 | pause() {
103 | if (!this.isRunning) {
104 | return;
105 | }
106 |
107 | clearInterval(this.tickInterval);
108 | clearTimeout(this.expireTimeout);
109 |
110 | let periodElapsed = (Date.now() - this.checkpointStartAt) / 1000;
111 | this.checkpointElapsed += periodElapsed;
112 |
113 | this.state = TimerState.Paused;
114 |
115 | this.emit('pause', this.status);
116 | }
117 |
118 | resume() {
119 | if (!this.isPaused) {
120 | return;
121 | }
122 |
123 | this.setExpireTimeout(this.remaining);
124 | this.setTickInterval(this.tick);
125 |
126 | this.state = TimerState.Running;
127 | this.checkpointStartAt = Date.now();
128 |
129 | this.emit('resume', this.status);
130 | }
131 |
132 | restart() {
133 | this.stop();
134 | this.start();
135 | }
136 |
137 | setExpireTimeout(seconds) {
138 | this.expireTimeout = setTimeout(() => {
139 | clearInterval(this.tickInterval);
140 | clearTimeout(this.expireTimeout);
141 |
142 | this.tickInterval = null;
143 | this.expireTimeout = null;
144 | this.checkpointStartAt = Date.now();
145 | this.checkpointElapsed = this.duration;
146 |
147 | this.state = TimerState.Stopped;
148 |
149 | this.emit('expire', this.status);
150 | }, seconds * 1000);
151 | }
152 |
153 | setTickInterval(seconds) {
154 | this.tickInterval = setInterval(() => {
155 | this.emit('tick', this.status);
156 | }, seconds * 1000);
157 | }
158 | }
159 |
160 | const Phase = new Enum({
161 | Focus: 0,
162 | ShortBreak: 1,
163 | LongBreak: 2
164 | });
165 |
166 | class PomodoroTimer extends EventEmitter
167 | {
168 | constructor(settings, initialPhase = Phase.Focus, timerType = Timer) {
169 | super();
170 | this.timerType = timerType;
171 | this.advanceTimer = false;
172 | this.pomodoros = 0;
173 | this.settings = settings;
174 | this.phase = initialPhase;
175 | }
176 |
177 | _updateTimer() {
178 | let { duration } = {
179 | [Phase.Focus]: this.settings.focus,
180 | [Phase.ShortBreak]: this.settings.shortBreak,
181 | [Phase.LongBreak]: this.settings.longBreak
182 | }[this.phase];
183 |
184 | if (this.timer) {
185 | this.timer.stop();
186 | this.timer.removeAllListeners();
187 | }
188 |
189 | this.timer = new this.timerType(Math.floor(duration * 60), 60);
190 | this.timer.observe(this);
191 | }
192 |
193 | get phase() {
194 | return this._phase;
195 | }
196 |
197 | set phase(newPhase) {
198 | if (!this.hasLongBreak && newPhase === Phase.LongBreak) {
199 | throw new Error('No long break interval defined.');
200 | }
201 |
202 | this._phase = newPhase;
203 | this._updateTimer();
204 | this.advanceTimer = false;
205 | }
206 |
207 | get nextPhase() {
208 | if (this.phase === Phase.ShortBreak || this.phase === Phase.LongBreak) {
209 | return Phase.Focus;
210 | }
211 |
212 | if (!this.hasLongBreak) {
213 | return Phase.ShortBreak;
214 | }
215 |
216 | if (this.pomodorosUntilLongBreak === 0) {
217 | return Phase.LongBreak;
218 | } else {
219 | return Phase.ShortBreak;
220 | }
221 | }
222 |
223 | get hasLongBreak() {
224 | return this.settings.longBreak.interval > 0;
225 | }
226 |
227 | get pomodorosUntilLongBreak() {
228 | let { interval } = this.settings.longBreak;
229 | if (!interval) {
230 | return null;
231 | }
232 |
233 | return interval - ((this.pomodoros - 1) % interval) - 1;
234 | }
235 |
236 | get remaining() {
237 | return this.timer.remaining;
238 | }
239 |
240 | get elapsed() {
241 | return this.timer.elapsed;
242 | }
243 |
244 | get state() {
245 | return this.timer.state;
246 | }
247 |
248 | get isRunning() {
249 | return this.timer.isRunning;
250 | }
251 |
252 | get isStopped() {
253 | return this.timer.isStopped;
254 | }
255 |
256 | get isPaused() {
257 | return this.timer.isPaused;
258 | }
259 |
260 | get status() {
261 | return {
262 | phase: this.phase,
263 | nextPhase: this.nextPhase,
264 | ...this.timer.status
265 | };
266 | }
267 |
268 | dispose() {
269 | this.timer.stop();
270 | this.timer.removeAllListeners();
271 | }
272 |
273 | startCycle() {
274 | this.pomodoros = 0;
275 | this.phase = Phase.Focus;
276 | this.start();
277 | }
278 |
279 | startFocus() {
280 | this.phase = Phase.Focus;
281 | this.start();
282 | }
283 |
284 | startShortBreak() {
285 | this.phase = Phase.ShortBreak;
286 | this.start();
287 | }
288 |
289 | startLongBreak() {
290 | this.phase = Phase.LongBreak;
291 | this.start();
292 | }
293 |
294 | start() {
295 | if (this.advanceTimer) {
296 | this._phase = this.nextPhase;
297 | this.advanceTimer = false;
298 | }
299 |
300 | this._updateTimer();
301 | this.timer.start();
302 | }
303 |
304 | pause() {
305 | return this.timer.pause();
306 | }
307 |
308 | stop() {
309 | return this.timer.stop();
310 | }
311 |
312 | resume() {
313 | return this.timer.resume();
314 | }
315 |
316 | restart() {
317 | // Calling timer.restart directly would ignore any settings changes, so
318 | // so we call start then stop to ensure we pick up on the changes.
319 | this.stop();
320 | return this.start();
321 | }
322 |
323 | observe(observer) {
324 | observer.onStart && this.on('start', (...args) => observer.onStart(...args));
325 | observer.onStop && this.on('stop', (...args) => observer.onStop(...args));
326 | observer.onPause && this.on('pause', (...args) => observer.onPause(...args));
327 | observer.onResume && this.on('resume', (...args) => observer.onResume(...args));
328 | observer.onTick && this.on('tick', (...args) => observer.onTick(...args));
329 | observer.onExpire && this.on('expire', (...args) => observer.onExpire(...args));
330 | }
331 |
332 | onStart(status) {
333 | this.emit('start', { phase: this.phase, nextPhase: this.nextPhase, ...status });
334 | }
335 |
336 | onStop(status) {
337 | this.emit('stop', { phase: this.phase, nextPhase: this.nextPhase, ...status });
338 | }
339 |
340 | onPause(status) {
341 | this.emit('pause', { phase: this.phase, nextPhase: this.nextPhase, ...status });
342 | }
343 |
344 | onResume(status) {
345 | this.emit('resume', { phase: this.phase, nextPhase: this.nextPhase, ...status });
346 | }
347 |
348 | onTick(status) {
349 | this.emit('tick', { phase: this.phase, nextPhase: this.nextPhase, ...status });
350 | }
351 |
352 | onExpire(status) {
353 | if (this.phase === Phase.Focus) {
354 | this.pomodoros++;
355 | }
356 |
357 | this.advanceTimer = true;
358 | this.emit('expire', { phase: this.phase, nextPhase: this.nextPhase, ...status });
359 | }
360 | }
361 |
362 | export {
363 | Timer,
364 | TimerState,
365 | Phase,
366 | PomodoroTimer
367 | };
--------------------------------------------------------------------------------
5 |
25 |
6 |
10 | {{ stats.day | integer }}
7 | {{ M.today }}
8 | {{ stats.dayAverage | float(2) | average_stat }}
9 |
11 |
15 | {{ stats.week | integer }}
12 | {{ M.this_week }}
13 | {{ stats.weekAverage | float(2) | average_stat }}
14 |
16 |
20 | {{ stats.month | integer }}
17 | {{ new Date() | strftime('%B') | in_month }}
18 | {{ stats.monthAverage | float(2) | average_stat }}
19 |
21 |
24 | {{ stats.total | integer }}
22 | {{ M.total }}
23 |
27 |
39 | {{ M.daily_distribution }}
28 | 38 |{{ M.daily_empty_placeholder }}
41 |
44 |
46 | {{ M.weekly_distribution }}
45 |{{ M.weekly_empty_placeholder }}
48 |
51 |
53 | {{ stats.period | pomodoroCount | last_9_months }}
52 |{{ M.history_empty_placeholder }}
55 | {{ M.your_history }}
58 |
59 |
76 |
60 |
61 |
63 | {{ M.save_as_csv_description }}
62 |
64 |
65 |
67 | {{ M.export_description }}
66 |
68 |
69 |
71 | {{ M.import_description }}
70 |
72 |
73 |
75 | {{ M.clear_history_description }}
74 |