-348

defaults.js

reviewed

··· 1 1 - 2 2 - const Store = require('electron-store'); 3 3 - 4 4 - const prefsSchema = { 5 5 - "$schema": "https://json-schema.org/draft/2020-12/schema", 6 6 - "$id": "peek.prefs.schema.json", 7 7 - "title": "Peek - prefs", 8 8 - "description": "Peek user preferences", 9 9 - "type": "object", 10 10 - "properties": { 11 11 - "globalKeyCmd": { 12 12 - "description": "Global OS hotkey to load app", 13 13 - "type": "string", 14 14 - "default": "CommandOrControl+Escape" 15 15 - }, 16 16 - "peekKeyPrefix": { 17 17 - "description": "Global OS hotkey prefix to trigger peeks - will be followed by 0-9", 18 18 - "type": "string", 19 19 - "default": "Option+" 20 20 - }, 21 21 - "slideKeyPrefix": { 22 22 - "description": "Global OS hotkey prefix to trigger slides - will be followed by U/D/L/R arrows", 23 23 - "type": "string", 24 24 - "default": "Option+" 25 25 - }, 26 26 - }, 27 27 - "required": [ "globalKeyCmd", "peekKeyPrefix"] 28 28 - }; 29 29 - 30 30 - const peekSchema = { 31 31 - "$schema": "https://json-schema.org/draft/2020-12/schema", 32 32 - "$id": "peek.peek.schema.json", 33 33 - "title": "Peek - page peek", 34 34 - "description": "Peek page peek", 35 35 - "type": "object", 36 36 - "properties": { 37 37 - "keyNum": { 38 38 - "description": "Number on keyboard to open this peek, 0-9", 39 39 - "type": "integer", 40 40 - "minimum": 0, 41 41 - "maximum": 9, 42 42 - "default": 0 43 43 - }, 44 44 - "title": { 45 45 - "description": "Name of the peek - user defined label", 46 46 - "type": "string", 47 47 - "default": "New Peek" 48 48 - }, 49 49 - "address": { 50 50 - "description": "URL to load", 51 51 - "type": "string", 52 52 - "default": "https://example.com" 53 53 - }, 54 54 - "persistState": { 55 55 - "description": "Whether to persist local state or load page into empty container - defaults to false", 56 56 - "type": "boolean", 57 57 - "default": false 58 58 - }, 59 59 - "keepLive": { 60 60 - "description": "Whether to keep page alive in background or load fresh when triggered - defaults to false", 61 61 - "type": "boolean", 62 62 - "default": false 63 63 - }, 64 64 - "allowSound": { 65 65 - "description": "Whether to allow the page to emit sound or not (eg for background music player peeks - defaults to false", 66 66 - "type": "boolean", 67 67 - "default": false 68 68 - }, 69 69 - "height": { 70 70 - "description": "User-defined height of peek page", 71 71 - "type": "integer", 72 72 - "default": 600 73 73 - }, 74 74 - "width": { 75 75 - "description": "User-defined width of peek page", 76 76 - "type": "integer", 77 77 - "default": 800 78 78 - }, 79 79 - }, 80 80 - "required": [ "keyNum", "title", "address", "persistState", "keepLive", "allowSound", 81 81 - "height", "width" ] 82 82 - }; 83 83 - 84 84 - const slideSchema = { 85 85 - "$schema": "https://json-schema.org/draft/2020-12/schema", 86 86 - "$id": "peek.slide.schema.json", 87 87 - "title": "Peek - page slide", 88 88 - "description": "Peek page slide", 89 89 - "type": "object", 90 90 - "properties": { 91 91 - "screenEdge": { 92 92 - "description": "Edge of screen or arrow key to open this slide, up/down/left/right", 93 93 - "type": "string", 94 94 - "oneOf": [ 95 95 - { "format": "Up" }, 96 96 - { "format": "Down" }, 97 97 - { "format": "Left" }, 98 98 - { "format": "Right" } 99 99 - ], 100 100 - "default": "Right" 101 101 - }, 102 102 - "title": { 103 103 - "description": "Name of the slide - user defined label", 104 104 - "type": "string", 105 105 - "default": "New Slide" 106 106 - }, 107 107 - "address": { 108 108 - "description": "URL to load", 109 109 - "type": "string", 110 110 - "default": "https://example.com" 111 111 - }, 112 112 - "persistState": { 113 113 - "description": "Whether to persist local state or load page into empty container - defaults to false", 114 114 - "type": "boolean", 115 115 - "default": false 116 116 - }, 117 117 - "keepLive": { 118 118 - "description": "Whether to keep page alive in background or load fresh when triggered - defaults to false", 119 119 - "type": "boolean", 120 120 - "default": false 121 121 - }, 122 122 - "allowSound": { 123 123 - "description": "Whether to allow the page to emit sound or not (eg for background music player slides - defaults to false", 124 124 - "type": "boolean", 125 125 - "default": false 126 126 - }, 127 127 - "height": { 128 128 - "description": "User-defined height of slide page", 129 129 - "type": "integer", 130 130 - "default": 600 131 131 - }, 132 132 - "width": { 133 133 - "description": "User-defined width of slide page", 134 134 - "type": "integer", 135 135 - "default": 800 136 136 - }, 137 137 - }, 138 138 - "required": [ "screenEdge", "title", "address", "persistState", "keepLive", "allowSound", 139 139 - "height", "width" ] 140 140 - }; 141 141 - 142 142 - const scriptSchema = { 143 143 - "$schema": "https://json-schema.org/draft/2020-12/schema", 144 144 - "$id": "peek.script.schema.json", 145 145 - "title": "Peek - script", 146 146 - "description": "Peek background script", 147 147 - "type": "object", 148 148 - "properties": { 149 149 - "id": { 150 150 - "description": "The unique identifier for a script", 151 151 - "type": "string", 152 152 - "default": "peek:script:REPLACEME" 153 153 - }, 154 154 - "title": { 155 155 - "description": "Name of the script - user defined", 156 156 - "type": "string", 157 157 - "default": "New Script" 158 158 - }, 159 159 - "version": { 160 160 - "description": "Version number of the script", 161 161 - "type": "string", 162 162 - "default": "1.0.0" 163 163 - }, 164 164 - "address": { 165 165 - "description": "URL to execute script against", 166 166 - "type": "string", 167 167 - "default": "https://example.com" 168 168 - }, 169 169 - "selector": { 170 170 - "description": "CSS Selector for the script", 171 171 - "type": "string", 172 172 - "default": "body > h1" 173 173 - }, 174 174 - "property": { 175 175 - "description": "Which element property to return - currently 'textContent' is the only supported value", 176 176 - "type": "string", 177 177 - "default": "textContent" 178 178 - }, 179 179 - "interval": { 180 180 - "description": "How often to execute the script, in milliseconds - defaults to five minutes", 181 181 - "type": "integer", 182 182 - "default": 300000, 183 183 - "minimum": 0 184 184 - }, 185 185 - "storeHistory": { 186 186 - "description": "Whether to store historic values - defaults to false", 187 187 - "type": "boolean", 188 188 - "default": false 189 189 - }, 190 190 - "notifyOnChange": { 191 191 - "description": "Whether to notify using local OS notifications when script value changes", 192 192 - "type": "boolean", 193 193 - "default": true 194 194 - }, 195 195 - "previousValue": { 196 196 - "description": "The most recently fetched result of script exection", 197 197 - "type": "string", 198 198 - "default": "", 199 199 - }, 200 200 - }, 201 201 - "required": [ "id", "title", "address", "version", "selector", "property", 202 202 - "interval", "notifyOnChange", "storeHistory" ] 203 203 - }; 204 204 - 205 205 - const schemas = { 206 206 - prefs: prefsSchema, 207 207 - peeks: peekSchema, 208 208 - slides: slideSchema, 209 209 - scripts: scriptSchema 210 210 - }; 211 211 - 212 212 - // TODO: schemaize 0-9 constraints for peeks and UPLR constraints for slides 213 213 - const fullSchema = { 214 214 - prefs: prefsSchema, 215 215 - peek: peekSchema, 216 216 - slide: slideSchema, 217 217 - script: scriptSchema, 218 218 - peeks: { 219 219 - type: 'array', 220 220 - items: { "$ref": "#/$defs/peek" } 221 221 - }, 222 222 - slides: { 223 223 - type: 'array', 224 224 - items: { "$ref": "#/$defs/slide" } 225 225 - }, 226 226 - scripts: { 227 227 - type: 'array', 228 228 - items: { "$ref": "#/$defs/script" } 229 229 - }, 230 230 - }; 231 231 - 232 232 - const defaults = { 233 233 - prefs: { 234 234 - globalKeyCmd: 'CommandOrControl+Escape', 235 235 - peekKeyPrefix: 'Option+', 236 236 - slideKeyPrefix: 'Option+' 237 237 - }, 238 238 - peeks: [], 239 239 - slides: [ 240 240 - { 241 241 - screenEdge: 'Up', 242 242 - title: 'Slide from top', 243 243 - address: 'http://localhost/', 244 244 - persistState: false, 245 245 - keepLive: false, 246 246 - allowSound: false, 247 247 - height: 600, 248 248 - width: 800, 249 249 - }, 250 250 - { 251 251 - screenEdge: 'Down', 252 252 - title: 'Slide from bottom', 253 253 - address: 'http://localhost/', 254 254 - persistState: false, 255 255 - keepLive: false, 256 256 - allowSound: false, 257 257 - height: 600, 258 258 - width: 800, 259 259 - }, 260 260 - { 261 261 - screenEdge: 'Left', 262 262 - title: 'Slide from left', 263 263 - address: 'http://localhost/', 264 264 - persistState: false, 265 265 - keepLive: false, 266 266 - allowSound: false, 267 267 - height: 600, 268 268 - width: 800, 269 269 - }, 270 270 - { 271 271 - screenEdge: 'Right', 272 272 - title: 'Slide from right', 273 273 - address: 'http://localhost/', 274 274 - persistState: false, 275 275 - keepLive: false, 276 276 - allowSound: false, 277 277 - height: 600, 278 278 - width: 800, 279 279 - }, 280 280 - ], 281 281 - scripts: [ 282 282 - { 283 283 - id: 'peek:script:localhost:test', 284 284 - title: 'localhost test', 285 285 - address: 'http://localhost/', 286 286 - version: '1', 287 287 - selector: 'body > h1', 288 288 - property: 'textContent', 289 289 - interval: 300000, 290 290 - storehistory: false, 291 291 - notifyOnChange: false 292 292 - }, 293 293 - ] 294 294 - }; 295 295 - 296 296 - for (var i = 0; i != 10; i++) { 297 297 - defaults.peeks.push({ 298 298 - keyNum: i, 299 299 - title: `Peek key ${i}`, 300 300 - address: 'http://localhost/', 301 301 - persistState: false, 302 302 - keepLive: false, 303 303 - allowSound: false, 304 304 - height: 600, 305 305 - width: 800, 306 306 - }); 307 307 - } 308 308 - 309 309 - const set = data => { 310 310 - store.set('prefs', data.prefs); 311 311 - store.set('peeks', data.peeks); 312 312 - store.set('slides', data.slides); 313 313 - store.set('scripts', data.scripts); 314 314 - }; 315 315 - 316 316 - const store = new Store({ 317 317 - // TODO: re-enable schemas 318 318 - //schema: fullSchema, 319 319 - watch: true 320 320 - }); 321 321 - 322 322 - // DEBUG 323 323 - store.clear(); 324 324 - 325 325 - const tmp = store.get('prefs'); 326 326 - if (!tmp) { 327 327 - console.log('initializing datastore'); 328 328 - store.set('prefs', defaults.prefs); 329 329 - store.set('peeks', defaults.peeks); 330 330 - store.set('slides', defaults.slides); 331 331 - store.set('scripts', defaults.scripts); 332 332 - } 333 333 - 334 334 - module.exports = { 335 335 - schemas, 336 336 - data: { 337 337 - get prefs() { return store.get('prefs'); }, 338 338 - get peeks() { return store.get('peeks'); }, 339 339 - get slides() { return store.get('slides'); }, 340 340 - get scripts() { return store.get('scripts'); } 341 341 - }, 342 342 - set, 343 343 - watch: fn => { 344 344 - store.onDidAnyChange(newData => { 345 345 - fn(newData) 346 346 - }); 347 347 - } 348 348 - };

+266

features/peeks/peeks.js

reviewed

··· 1 1 + // peeks/peek.js 2 2 + (async () => { 3 3 + 4 4 + console.log('peeks/peeks'); 5 5 + 6 6 + const labels = { 7 7 + featureType: 'peeks', 8 8 + featureDisplay: 'Peeks', 9 9 + itemType: 'peek', 10 10 + itemDisplay: 'Peek', 11 11 + prefs: { 12 12 + keyPrefix: 'Peek shortcut prefix', 13 13 + } 14 14 + }; 15 15 + 16 16 + const { 17 17 + BrowserWindow, 18 18 + globalShortcut, 19 19 + } = require('electron'); 20 20 + 21 21 + const path = require('path'); 22 22 + 23 23 + let _store = null; 24 24 + 25 25 + const prefsSchema = { 26 26 + "$schema": "https://json-schema.org/draft/2020-12/schema", 27 27 + "$id": "peek.peeks.prefs.schema.json", 28 28 + "title": "Peek - peeks", 29 29 + "description": "Peek app Peeks prefs", 30 30 + "type": "object", 31 31 + "properties": { 32 32 + "shortcutKeyPrefix": { 33 33 + "description": "Global OS hotkey prefix to trigger peeks - will be followed by 0-9", 34 34 + "type": "string", 35 35 + "default": "Option+" 36 36 + }, 37 37 + }, 38 38 + "required": [ "shortcutKeyPrefix"] 39 39 + }; 40 40 + 41 41 + const itemSchema = { 42 42 + "$schema": "https://json-schema.org/draft/2020-12/schema", 43 43 + "$id": "peek.peeks.peek.schema.json", 44 44 + "title": "Peek - page peek", 45 45 + "description": "Peek page peek", 46 46 + "type": "object", 47 47 + "properties": { 48 48 + "keyNum": { 49 49 + "description": "Number on keyboard to open this peek, 0-9", 50 50 + "type": "integer", 51 51 + "minimum": 0, 52 52 + "maximum": 9, 53 53 + "default": 0 54 54 + }, 55 55 + "title": { 56 56 + "description": "Name of the peek - user defined label", 57 57 + "type": "string", 58 58 + "default": "New Peek" 59 59 + }, 60 60 + "address": { 61 61 + "description": "URL to load", 62 62 + "type": "string", 63 63 + "default": "https://example.com" 64 64 + }, 65 65 + "persistState": { 66 66 + "description": "Whether to persist local state or load page into empty container - defaults to false", 67 67 + "type": "boolean", 68 68 + "default": false 69 69 + }, 70 70 + "keepLive": { 71 71 + "description": "Whether to keep page alive in background or load fresh when triggered - defaults to false", 72 72 + "type": "boolean", 73 73 + "default": false 74 74 + }, 75 75 + "allowSound": { 76 76 + "description": "Whether to allow the page to emit sound or not (eg for background music player peeks - defaults to false", 77 77 + "type": "boolean", 78 78 + "default": false 79 79 + }, 80 80 + "height": { 81 81 + "description": "User-defined height of peek page", 82 82 + "type": "integer", 83 83 + "default": 600 84 84 + }, 85 85 + "width": { 86 86 + "description": "User-defined width of peek page", 87 87 + "type": "integer", 88 88 + "default": 800 89 89 + }, 90 90 + }, 91 91 + "required": [ "keyNum", "title", "address", "persistState", "keepLive", "allowSound", 92 92 + "height", "width" ] 93 93 + }; 94 94 + 95 95 + const listSchema = { 96 96 + type: 'array', 97 97 + items: { "$ref": "#/$defs/peek" } 98 98 + }; 99 99 + 100 100 + // TODO: schemaize 0-9 constraints for peeks 101 101 + const schemas = { 102 102 + prefs: prefsSchema, 103 103 + item: itemSchema, 104 104 + items: listSchema 105 105 + }; 106 106 + 107 107 + const _defaults = { 108 108 + prefs: { 109 109 + shortcutKeyPrefix: 'Option+' 110 110 + }, 111 111 + items: Array.from(Array(10)), 112 112 + }; 113 113 + 114 114 + for (var i = 0; i != 10; i++) { 115 115 + _defaults.items[i] = { 116 116 + keyNum: i, 117 117 + title: `Peek key ${i}`, 118 118 + address: 'https://example.com/', 119 119 + persistState: false, 120 120 + keepLive: false, 121 121 + allowSound: false, 122 122 + height: 600, 123 123 + width: 800, 124 124 + }; 125 125 + } 126 126 + 127 127 + let _windows = {}; 128 128 + 129 129 + const executeItem = (api, item) => { 130 130 + const height = item.height || 600; 131 131 + const width = item.width || 800; 132 132 + 133 133 + let win = null; 134 134 + 135 135 + const windowKey = labels.featureType + item.keyNum; 136 136 + 137 137 + if (_windows[windowKey]) { 138 138 + console.log(labels.featureType, item.keyNum, 'using stored window'); 139 139 + win = _windows[windowKey]; 140 140 + win.show(); 141 141 + } 142 142 + else { 143 143 + console.log(labels.featureType, item.keyNum, 'creating new window'); 144 144 + 145 145 + win = new BrowserWindow({ 146 146 + height, 147 147 + width, 148 148 + center: true, 149 149 + skipTaskbar: true, 150 150 + autoHideMenuBar: true, 151 151 + titleBarStyle: 'hidden', 152 152 + webPreferences: { 153 153 + preload: api.preloadPath, 154 154 + // isolate content and do not persist it 155 155 + partition: Date.now() 156 156 + } 157 157 + }); 158 158 + 159 159 + //_windows[windowKey] = win; 160 160 + } 161 161 + 162 162 + const onGoAway = () => { 163 163 + /* 164 164 + if (item.keepLive) { 165 165 + _windows[windowKey] = win; 166 166 + win.hide(); 167 167 + } 168 168 + else { 169 169 + win.destroy(); 170 170 + } 171 171 + */ 172 172 + win.destroy(); 173 173 + } 174 174 + win.on('blur', onGoAway); 175 175 + win.on('close', onGoAway); 176 176 + 177 177 + win.webContents.send('window', { type: labels.featureType, id: win.id, data: item }); 178 178 + 179 179 + win.loadURL(item.address); 180 180 + }; 181 181 + 182 182 + const initStore = (store, data) => { 183 183 + const sp = store.get('prefs'); 184 184 + if (!sp) { 185 185 + store.set('prefs', data.prefs); 186 186 + } 187 187 + 188 188 + const items = store.get('items'); 189 189 + if (!items) { 190 190 + store.set('items', data.items); 191 191 + } 192 192 + }; 193 193 + 194 194 + const initItems = (api, prefs, items) => { 195 195 + const cmdPrefix = prefs.shortcutKeyPrefix; 196 196 + 197 197 + items.forEach(item => { 198 198 + const shortcut = `${cmdPrefix}${item.keyNum}`; 199 199 + 200 200 + if (globalShortcut.isRegistered(shortcut)) { 201 201 + globalShortcut.unregister(shortcut); 202 202 + } 203 203 + 204 204 + const ret = globalShortcut.register(shortcut, () => { 205 205 + executeItem(api, item); 206 206 + }); 207 207 + 208 208 + if (!ret) { 209 209 + console.error('Unable to register shortcut', shortcut); 210 210 + } 211 211 + }); 212 212 + }; 213 213 + 214 214 + const init = (api, store) => { 215 215 + _store = store; 216 216 + _api = api; 217 217 + 218 218 + initStore(_store, _defaults); 219 219 + 220 220 + _data = { 221 221 + get prefs() { return _store.get('prefs'); }, 222 222 + get items() { return _store.get('items'); }, 223 223 + }; 224 224 + 225 225 + // initialize peeks 226 226 + if (_data.items.length > 0) { 227 227 + initItems(api, _data.prefs, _data.items); 228 228 + } 229 229 + }; 230 230 + 231 231 + const onChange = (changed, old) => { 232 232 + console.log(labels.featureType, 'onChange', changed); 233 233 + 234 234 + // TODO only update store if changed 235 235 + // and re-init 236 236 + if (changed.prefs) { 237 237 + _store.set('prefs', changed.prefs); 238 238 + } 239 239 + 240 240 + if (changed.items) { 241 241 + _store.set('items', changed.items); 242 242 + } 243 243 + }; 244 244 + 245 245 + // ui config 246 246 + const config = { 247 247 + // allow user to create new items 248 248 + allowNew: false, 249 249 + // fields that are view only 250 250 + disabled: ['keyNum'], 251 251 + }; 252 252 + 253 253 + module.exports = { 254 254 + init: init, 255 255 + config, 256 256 + labels, 257 257 + schemas, 258 258 + data: { 259 259 + get prefs() { return _store.get('prefs'); }, 260 260 + get items() { return _store.get('items'); }, 261 261 + }, 262 262 + onChange 263 263 + }; 264 264 + 265 265 + 266 266 + })();

features/scripts/.scripts.js.swp

reviewed

This is a binary file and will not be displayed.

+279

features/scripts/scripts.js

reviewed

··· 1 1 + // scripts/scripts.js 2 2 + (async () => { 3 3 + 4 4 + console.log('scripts/scripts'); 5 5 + 6 6 + const labels = { 7 7 + featureType: 'scripts', 8 8 + featureDisplay: 'Scripts', 9 9 + itemType: 'script', 10 10 + itemDisplay: 'Script', 11 11 + prefs: { 12 12 + } 13 13 + }; 14 14 + 15 15 + const { 16 16 + BrowserWindow, 17 17 + globalShortcut, 18 18 + screen, 19 19 + } = require('electron'); 20 20 + 21 21 + const path = require('path'); 22 22 + 23 23 + let _store = null; 24 24 + 25 25 + const prefsSchema = { 26 26 + "$schema": "https://json-schema.org/draft/2020-12/schema", 27 27 + "$id": "peek.scripts.prefs.schema.json", 28 28 + "title": "Peek - Scripts prefs", 29 29 + "description": "Peek app Scripts prefs", 30 30 + "type": "object", 31 31 + "properties": { 32 32 + }, 33 33 + "required": [] 34 34 + }; 35 35 + 36 36 + const itemSchema = { 37 37 + "$schema": "https://json-schema.org/draft/2020-12/schema", 38 38 + "$id": "peek.scripts.script.schema.json", 39 39 + "title": "Peek - script", 40 40 + "description": "Peek background script", 41 41 + "type": "object", 42 42 + "properties": { 43 43 + "id": { 44 44 + "description": "The unique identifier for a script", 45 45 + "type": "string", 46 46 + "default": "peek:script:REPLACEME" 47 47 + }, 48 48 + "title": { 49 49 + "description": "Name of the script - user defined", 50 50 + "type": "string", 51 51 + "default": "New Script" 52 52 + }, 53 53 + "version": { 54 54 + "description": "Version number of the script", 55 55 + "type": "string", 56 56 + "default": "1.0.0" 57 57 + }, 58 58 + "address": { 59 59 + "description": "URL to execute script against", 60 60 + "type": "string", 61 61 + "default": "https://example.com" 62 62 + }, 63 63 + "selector": { 64 64 + "description": "CSS Selector for the script", 65 65 + "type": "string", 66 66 + "default": "body > h1" 67 67 + }, 68 68 + "property": { 69 69 + "description": "Which element property to return - currently 'textContent' is the only supported value", 70 70 + "type": "string", 71 71 + "default": "textContent" 72 72 + }, 73 73 + "interval": { 74 74 + "description": "How often to execute the script, in milliseconds - defaults to five minutes", 75 75 + "type": "integer", 76 76 + "default": 300000, 77 77 + "minimum": 0 78 78 + }, 79 79 + "storeHistory": { 80 80 + "description": "Whether to store historic values - defaults to false", 81 81 + "type": "boolean", 82 82 + "default": false 83 83 + }, 84 84 + "notifyOnChange": { 85 85 + "description": "Whether to notify using local OS notifications when script value changes", 86 86 + "type": "boolean", 87 87 + "default": true 88 88 + }, 89 89 + "previousValue": { 90 90 + "description": "The most recently fetched result of script exection", 91 91 + "type": "string", 92 92 + "default": "", 93 93 + }, 94 94 + }, 95 95 + "required": [ "id", "title", "address", "version", "selector", "property", 96 96 + "interval", "notifyOnChange", "storeHistory" ] 97 97 + }; 98 98 + 99 99 + const listSchema = { 100 100 + type: 'array', 101 101 + items: { "$ref": "#/$defs/script" } 102 102 + }; 103 103 + 104 104 + // TODO: schemaize 0-9 constraints for peeks 105 105 + const schemas = { 106 106 + prefs: prefsSchema, 107 107 + item: itemSchema, 108 108 + items: listSchema 109 109 + }; 110 110 + 111 111 + const _defaults = { 112 112 + prefs: { 113 113 + }, 114 114 + items: [ 115 115 + { 116 116 + id: 'peek:script:localhost:test', 117 117 + title: 'localhost test', 118 118 + address: 'http://localhost/', 119 119 + version: '1', 120 120 + selector: 'body > h1', 121 121 + property: 'textContent', 122 122 + interval: 300000, 123 123 + storehistory: false, 124 124 + notifyOnChange: false 125 125 + }, 126 126 + ] 127 127 + }; 128 128 + 129 129 + let _windows = {}; 130 130 + 131 131 + const executeItem = (api, script, cb) => { 132 132 + const view = new BrowserWindow({ 133 133 + show: false, 134 134 + webPreferences: { 135 135 + preload: api.preloadPath, 136 136 + // isolate content and do not persist it 137 137 + partition: Date.now() 138 138 + } 139 139 + }); 140 140 + 141 141 + view.webContents.send('window', { 142 142 + id: 'view', 143 143 + type: 'script', 144 144 + data: script 145 145 + }); 146 146 + 147 147 + view.webContents.loadURL(script.address); 148 148 + 149 149 + const str = ` 150 150 + const s = "${script.selector}"; 151 151 + const r = document.querySelector(s); 152 152 + const value = r ? r.textContent : null; 153 153 + value; 154 154 + `; 155 155 + 156 156 + view.webContents.on('dom-ready', async () => { 157 157 + try { 158 158 + const r = await view.webContents.executeJavaScript(str); 159 159 + cb(r); 160 160 + } catch(ex) { 161 161 + console.error('cs exec error', ex); 162 162 + cb(null); 163 163 + } 164 164 + view.destroy(); 165 165 + }); 166 166 + }; 167 167 + 168 168 + const initStore = (store, data) => { 169 169 + const sp = store.get('prefs'); 170 170 + if (!sp) { 171 171 + store.set('prefs', data.prefs); 172 172 + } 173 173 + 174 174 + const items = store.get('items'); 175 175 + if (!items) { 176 176 + store.set('items', data.items); 177 177 + } 178 178 + }; 179 179 + 180 180 + let _intervals = []; 181 181 + 182 182 + const initItems = (api, prefs, items) => { 183 183 + // blow it all away for now 184 184 + // someday make it right proper just cancel/update changed and add new 185 185 + _intervals.forEach(clearInterval); 186 186 + 187 187 + // debounce me somehow so not shooting em all off 188 188 + // at once every time app starts 189 189 + items.forEach(item => { 190 190 + const interval = setInterval(() => { 191 191 + //console.log('interval hit', item.title); 192 192 + const r = executeItem(api, item, (res) => { 193 193 + //console.log('cs r', res); 194 194 + 195 195 + if (item.previousValue != res) { 196 196 + 197 197 + // update stored value 198 198 + item.previousValue = res; 199 199 + updateItem(item); 200 200 + 201 201 + // notification 202 202 + // add to schema and support per script 203 203 + /* 204 204 + const title = `Peek :: Script :: ${item.title}`; 205 205 + const body = [ 206 206 + `Script result changed for ${item.title}:`, 207 207 + `- Old: ${previousValue}`, 208 208 + `- New: ${res}` 209 209 + ].join('\n'); 210 210 + 211 211 + new Notification({ title, body }).show(); 212 212 + */ 213 213 + } 214 214 + }); 215 215 + }, item.interval); 216 216 + _intervals.push(interval); 217 217 + }); 218 218 + }; 219 219 + 220 220 + const init = (api, store) => { 221 221 + _store = store; 222 222 + _api = api; 223 223 + 224 224 + initStore(_store, _defaults); 225 225 + 226 226 + _data = { 227 227 + get prefs() { return _store.get('prefs'); }, 228 228 + get items() { return _store.get('items'); }, 229 229 + }; 230 230 + 231 231 + // initialize peeks 232 232 + if (_data.items.length > 0) { 233 233 + initItems(api, _data.prefs, _data.items); 234 234 + } 235 235 + }; 236 236 + 237 237 + const updateItem = (item) => { 238 238 + let items = _store.get('items'); 239 239 + const idx = items.findIndex(el => el.id == item.id); 240 240 + items[idx] = item; 241 241 + _store.set('items', items); 242 242 + }; 243 243 + 244 244 + const onChange = (changed, old) => { 245 245 + console.log(labels.featureType, 'onChange', changed); 246 246 + 247 247 + // TODO only update store if changed 248 248 + // and re-init 249 249 + if (changed.prefs) { 250 250 + _store.set('prefs', changed.prefs); 251 251 + } 252 252 + 253 253 + if (changed.items) { 254 254 + _store.set('items', changed.items); 255 255 + } 256 256 + }; 257 257 + 258 258 + // ui config 259 259 + const config = { 260 260 + // allow user to create new items 261 261 + allowNew: false, 262 262 + // fields that are view only 263 263 + disabled: ['screenEdge'], 264 264 + }; 265 265 + 266 266 + module.exports = { 267 267 + init: init, 268 268 + config, 269 269 + labels, 270 270 + schemas, 271 271 + data: { 272 272 + get prefs() { return _store.get('prefs'); }, 273 273 + get items() { return _store.get('items'); }, 274 274 + }, 275 275 + onChange 276 276 + }; 277 277 + 278 278 + 279 279 + })();

+433

features/slides/slides.js

reviewed

··· 1 1 + // slides/slides.js 2 2 + (async () => { 3 3 + 4 4 + console.log('slides/slides'); 5 5 + 6 6 + const labels = { 7 7 + featureType: 'slides', 8 8 + featureDisplay: 'Slides', 9 9 + itemType: 'slide', 10 10 + itemDisplay: 'Slide', 11 11 + prefs: { 12 12 + keyPrefix: 'Slide shortcut prefix', 13 13 + } 14 14 + }; 15 15 + 16 16 + const { 17 17 + BrowserWindow, 18 18 + globalShortcut, 19 19 + screen, 20 20 + } = require('electron'); 21 21 + 22 22 + const path = require('path'); 23 23 + 24 24 + let _store = null; 25 25 + 26 26 + const prefsSchema = { 27 27 + "$schema": "https://json-schema.org/draft/2020-12/schema", 28 28 + "$id": "peek.slides.prefs.schema.json", 29 29 + "title": "Peek - Slides prefs", 30 30 + "description": "Peek app Slides prefs", 31 31 + "type": "object", 32 32 + "properties": { 33 33 + "shortcutKeyPrefix": { 34 34 + "description": "Global OS hotkey prefix to trigger slides - will be followed by up/down/left/right arrows", 35 35 + "type": "string", 36 36 + "default": "Option+" 37 37 + }, 38 38 + }, 39 39 + "required": [ "shortcutKeyPrefix"] 40 40 + }; 41 41 + 42 42 + const itemSchema = { 43 43 + "$schema": "https://json-schema.org/draft/2020-12/schema", 44 44 + "$id": "peek.slides.slide.schema.json", 45 45 + "title": "Peek - page slide", 46 46 + "description": "Peek page slide", 47 47 + "type": "object", 48 48 + "properties": { 49 49 + "screenEdge": { 50 50 + "description": "Edge of screen or arrow key to open this slide, up/down/left/right", 51 51 + "type": "string", 52 52 + "oneOf": [ 53 53 + { "format": "Up" }, 54 54 + { "format": "Down" }, 55 55 + { "format": "Left" }, 56 56 + { "format": "Right" } 57 57 + ], 58 58 + "default": "Right" 59 59 + }, 60 60 + "title": { 61 61 + "description": "Name of the slide - user defined label", 62 62 + "type": "string", 63 63 + "default": "New Slide" 64 64 + }, 65 65 + "address": { 66 66 + "description": "URL to load", 67 67 + "type": "string", 68 68 + "default": "https://example.com" 69 69 + }, 70 70 + "persistState": { 71 71 + "description": "Whether to persist local state or load page into empty container - defaults to false", 72 72 + "type": "boolean", 73 73 + "default": false 74 74 + }, 75 75 + "keepLive": { 76 76 + "description": "Whether to keep page alive in background or load fresh when triggered - defaults to false", 77 77 + "type": "boolean", 78 78 + "default": false 79 79 + }, 80 80 + "allowSound": { 81 81 + "description": "Whether to allow the page to emit sound or not (eg for background music player slides - defaults to false", 82 82 + "type": "boolean", 83 83 + "default": false 84 84 + }, 85 85 + "height": { 86 86 + "description": "User-defined height of slide page", 87 87 + "type": "integer", 88 88 + "default": 600 89 89 + }, 90 90 + "width": { 91 91 + "description": "User-defined width of slide page", 92 92 + "type": "integer", 93 93 + "default": 800 94 94 + }, 95 95 + }, 96 96 + "required": [ "screenEdge", "title", "address", "persistState", "keepLive", "allowSound", 97 97 + "height", "width" ] 98 98 + }; 99 99 + 100 100 + const listSchema = { 101 101 + type: 'array', 102 102 + items: { "$ref": "#/$defs/slide" } 103 103 + }; 104 104 + 105 105 + // TODO: schemaize 0-9 constraints for peeks 106 106 + const schemas = { 107 107 + prefs: prefsSchema, 108 108 + item: itemSchema, 109 109 + items: listSchema 110 110 + }; 111 111 + 112 112 + const _defaults = { 113 113 + prefs: { 114 114 + shortcutKeyPrefix: 'Option+' 115 115 + }, 116 116 + items: [ 117 117 + { 118 118 + screenEdge: 'Up', 119 119 + title: 'Slide from top', 120 120 + address: 'http://localhost/', 121 121 + persistState: false, 122 122 + keepLive: false, 123 123 + allowSound: false, 124 124 + height: 600, 125 125 + width: 800, 126 126 + }, 127 127 + { 128 128 + screenEdge: 'Down', 129 129 + title: 'Slide from bottom', 130 130 + address: 'http://localhost/', 131 131 + persistState: false, 132 132 + keepLive: false, 133 133 + allowSound: false, 134 134 + height: 600, 135 135 + width: 800, 136 136 + }, 137 137 + { 138 138 + screenEdge: 'Left', 139 139 + title: 'Slide from left', 140 140 + address: 'http://localhost/', 141 141 + persistState: false, 142 142 + keepLive: false, 143 143 + allowSound: false, 144 144 + height: 600, 145 145 + width: 800, 146 146 + }, 147 147 + { 148 148 + screenEdge: 'Right', 149 149 + title: 'Slide from right', 150 150 + address: 'http://localhost/', 151 151 + persistState: false, 152 152 + keepLive: false, 153 153 + allowSound: false, 154 154 + height: 600, 155 155 + width: 800, 156 156 + }, 157 157 + ] 158 158 + }; 159 159 + 160 160 + let _windows = {}; 161 161 + 162 162 + const executeItem = (api, item) => { 163 163 + let win = null; 164 164 + 165 165 + const windowKey = labels.featureType + item.screenEdge; 166 166 + 167 167 + // TODO: fix stored+live windows 168 168 + if (_windows[windowKey]) { 169 169 + console.log(labels.featureType, slide.screenEdge, 'using stored window'); 170 170 + win = _windows[windowKey]; 171 171 + win.show(); 172 172 + } 173 173 + else { 174 174 + const { size, bounds } = screen.getPrimaryDisplay(); 175 175 + 176 176 + let x, y, height, width, center = null; 177 177 + 178 178 + switch(item.screenEdge) { 179 179 + case 'Up': 180 180 + // horizontally center 181 181 + x = (size.width - item.width) / 2; 182 182 + 183 183 + // y starts at screen top and stays there 184 184 + y = 0; 185 185 + 186 186 + width = item.width; 187 187 + height = 1; 188 188 + break; 189 189 + case 'Down': 190 190 + // horizonally center 191 191 + x = (size.width - item.width) / 2; 192 192 + 193 193 + // y ends up at window height from bottom 194 194 + // 195 195 + // eg: y = size.height - item.height; 196 196 + // 197 197 + // but starts at screen bottom 198 198 + y = size.height; 199 199 + 200 200 + width = item.width; 201 201 + height = 1; 202 202 + break; 203 203 + case 'Left': 204 204 + // x starts and ends at at left screen edge 205 205 + // at left edge 206 206 + x = 0; 207 207 + 208 208 + // vertically center 209 209 + y = (size.height - item.height) / 2; 210 210 + 211 211 + width = 1; 212 212 + height = item.height; 213 213 + break; 214 214 + case 'Right': 215 215 + // x ends at at right screen edge - window size 216 216 + // 217 217 + // eg: x = size.width - item.width; 218 218 + // 219 219 + // but starts at screen right edge, will animate in 220 220 + x = size.width; 221 221 + 222 222 + // vertically center 223 223 + y = (size.height - item.height) / 2; 224 224 + 225 225 + width = 1; 226 226 + height = item.height; 227 227 + break; 228 228 + default: 229 229 + center = true; 230 230 + console.log('waddafa'); 231 231 + } 232 232 + 233 233 + win = new BrowserWindow({ 234 234 + height, 235 235 + width, 236 236 + x, 237 237 + y, 238 238 + skipTaskbar: true, 239 239 + autoHideMenuBar: true, 240 240 + titleBarStyle: 'hidden', 241 241 + // maybe worth doing instead of animating width 242 242 + //enableLargerThanScreen: true, 243 243 + webPreferences: { 244 244 + preload: api.preloadPath, 245 245 + // isolate content and do not persist it 246 246 + partition: Date.now() 247 247 + } 248 248 + }); 249 249 + 250 250 + //_windows[windowKey] = win; 251 251 + } 252 252 + 253 253 + animateSlide(win, item).then(); 254 254 + 255 255 + const onGoAway = () => { 256 256 + /* 257 257 + if (item.keepLive) { 258 258 + _windows[key] = win; 259 259 + win.hide(); 260 260 + } 261 261 + else { 262 262 + win.destroy(); 263 263 + } 264 264 + */ 265 265 + win.destroy(); 266 266 + } 267 267 + win.on('blur', onGoAway); 268 268 + win.on('close', onGoAway); 269 269 + 270 270 + /* 271 271 + const str = ` 272 272 + window.addEventListener('keyup', e => { 273 273 + if (e.key == 'Escape') { 274 274 + console.log('peek script esc'); 275 275 + } 276 276 + }); 277 277 + 1; 278 278 + `; 279 279 + 280 280 + win.webContents.on('dom-ready', async () => { 281 281 + try { 282 282 + const r = await win.webContents.executeJavaScript(str); 283 283 + console.log(r); 284 284 + } catch(ex) { 285 285 + console.error('cs exec error', ex); 286 286 + } 287 287 + }); 288 288 + */ 289 289 + 290 290 + win.webContents.send('window', { type: labels.featureType, id: win.id, data: item }); 291 291 + 292 292 + win.loadURL(item.address); 293 293 + }; 294 294 + 295 295 + const initStore = (store, data) => { 296 296 + const sp = store.get('prefs'); 297 297 + if (!sp) { 298 298 + store.set('prefs', data.prefs); 299 299 + } 300 300 + 301 301 + const items = store.get('items'); 302 302 + if (!items) { 303 303 + store.set('items', data.items); 304 304 + } 305 305 + }; 306 306 + 307 307 + const initItems = (api, prefs, items) => { 308 308 + const cmdPrefix = prefs.shortcutKeyPrefix; 309 309 + 310 310 + items.forEach(item => { 311 311 + const shortcut = `${cmdPrefix}${item.screenEdge}`; 312 312 + 313 313 + if (globalShortcut.isRegistered(shortcut)) { 314 314 + globalShortcut.unregister(shortcut); 315 315 + } 316 316 + 317 317 + const ret = globalShortcut.register(shortcut, () => { 318 318 + executeItem(api, item); 319 319 + }); 320 320 + 321 321 + if (!ret) { 322 322 + console.error('Unable to register shortcut', shortcut); 323 323 + } 324 324 + }); 325 325 + }; 326 326 + 327 327 + const init = (api, store) => { 328 328 + _store = store; 329 329 + _api = api; 330 330 + 331 331 + initStore(_store, _defaults); 332 332 + 333 333 + _data = { 334 334 + get prefs() { return _store.get('prefs'); }, 335 335 + get items() { return _store.get('items'); }, 336 336 + }; 337 337 + 338 338 + // initialize peeks 339 339 + if (_data.items.length > 0) { 340 340 + initItems(api, _data.prefs, _data.items); 341 341 + } 342 342 + }; 343 343 + 344 344 + const onChange = (changed, old) => { 345 345 + console.log(labels.featureType, 'onChange', changed); 346 346 + 347 347 + // TODO only update store if changed 348 348 + // and re-init 349 349 + if (changed.prefs) { 350 350 + _store.set('prefs', changed.prefs); 351 351 + } 352 352 + 353 353 + if (changed.items) { 354 354 + _store.set('items', changed.items); 355 355 + } 356 356 + }; 357 357 + 358 358 + // ui config 359 359 + const config = { 360 360 + // allow user to create new items 361 361 + allowNew: false, 362 362 + // fields that are view only 363 363 + disabled: ['screenEdge'], 364 364 + }; 365 365 + 366 366 + module.exports = { 367 367 + init: init, 368 368 + config, 369 369 + labels, 370 370 + schemas, 371 371 + data: { 372 372 + get prefs() { return _store.get('prefs'); }, 373 373 + get items() { return _store.get('items'); }, 374 374 + }, 375 375 + onChange 376 376 + }; 377 377 + 378 378 + const animateSlide = (win, slide) => { 379 379 + return new Promise((res, rej) => { 380 380 + const { size, bounds } = screen.getPrimaryDisplay(); 381 381 + 382 382 + // get x/y field 383 383 + const coord = slide.screenEdge == 'Left' || slide.screenEdge == 'Right' ? 'x' : 'y'; 384 384 + 385 385 + const dim = coord == 'x' ? 'width' : 'height'; 386 386 + 387 387 + const winBounds = win.getBounds(); 388 388 + 389 389 + // created window at x/y taking animation into account 390 390 + let pos = winBounds[coord]; 391 391 + 392 392 + const speedMs = 150; 393 393 + const timerInterval = 10; 394 394 + 395 395 + let tick = 0; 396 396 + const numTicks = parseInt(speedMs / timerInterval); 397 397 + 398 398 + const offset = slide[dim] / numTicks; 399 399 + 400 400 + //console.log('numTicks', numTicks, 'widthChunk', offset); 401 401 + 402 402 + const timer = setInterval(() => { 403 403 + tick++; 404 404 + 405 405 + if (tick >= numTicks) { 406 406 + clearInterval(timer); 407 407 + res(); 408 408 + } 409 409 + 410 410 + const winBounds = win.getBounds(); 411 411 + 412 412 + if (slide.screenEdge == 'Right' || slide.screenEdge == 'Down') { 413 413 + // new position is current position +/- offset 414 414 + pos = pos - offset; 415 415 + } 416 416 + 417 417 + const grownEnough = winBounds[dim] <= slide[dim]; 418 418 + const newDim = grownEnough ? 419 419 + winBounds[dim] + offset 420 420 + : winBounds[dim]; 421 421 + 422 422 + const newBounds = {}; 423 423 + newBounds[coord] = parseInt(pos, 10); 424 424 + newBounds[dim] = parseInt(newDim, 10); 425 425 + 426 426 + // set new bounds 427 427 + win.setBounds(newBounds); 428 428 + 429 429 + }, timerInterval); 430 430 + }); 431 431 + }; 432 432 + 433 433 + })();

+138 -401

index.js

reviewed

··· 14 14 Menu, 15 15 nativeTheme, 16 16 Notification, 17 17 - screen, 18 17 Tray 19 18 } = require('electron'); 20 19 21 20 const path = require('path'); 21 21 + const preloadPath = path.join(__dirname, 'preload.js'); 22 22 + 23 23 + const Store = require('electron-store'); 24 24 + 25 25 + const features = { 26 26 + peeks: require('./features/peeks/peeks'), 27 27 + slides: require('./features/slides/slides'), 28 28 + scripts: require('./features/scripts/scripts'), 29 29 + }; 22 30 23 31 const labels = { 24 32 app: { 33 33 + key: 'peek', 25 34 title: 'Peek' 26 35 }, 27 36 tray: { 28 28 - tooltip: 'Click to open Peek' 37 37 + tooltip: 'Click to open' 29 38 } 30 39 }; 31 31 - 32 32 - // load data 33 33 - let { data, schemas, set, watch } = require('./defaults'); 34 40 35 41 const ICON_RELATIVE_PATH = 'assets/icons/AppIcon.appiconset/Icon-App-20x20@2x.png'; 36 42 const ICON_PATH = path.join(__dirname, ICON_RELATIVE_PATH); ··· 68 74 }); 69 75 70 76 let _windows = []; 71 71 - let _peekWins = {}; 72 72 - let _slideWins = {}; 73 77 74 78 // main window 75 79 let _win = null; 80 80 + 76 81 // tray 77 82 let _tray = null; 78 83 ··· 84 89 }; 85 90 86 91 const createMainWindow = () => { 87 87 - console.log('createMainWindow'); 92 92 + console.log('createMainWindow, preloadPath', preloadPath); 88 93 // Create the browser window. 89 94 const mainWindow = new BrowserWindow({ 90 95 width: 800, 91 96 height: 600, 92 97 webPreferences: { 93 93 - preload: path.join(__dirname, 'preload.js') 98 98 + preload: preloadPath 94 99 } 95 100 }); 96 101 ··· 108 113 // Open the DevTools. 109 114 mainWindow.webContents.openDevTools() 110 115 116 116 + mainWindow.webContents.send('window', { 117 117 + path: path.join(__dirname), 118 118 + id: mainWindow.id, 119 119 + type: 'main', 120 120 + }); 121 121 + 122 122 + _windows.push(mainWindow); 123 123 + /* 124 124 + mainWindow.on('closed', () => { 125 125 + const idx = _windows.findIndex(mainWindow); 126 126 + //_windows. 127 127 + }); 128 128 + */ 129 129 + 111 130 return mainWindow; 112 131 }; 113 132 ··· 131 150 return _tray; 132 151 }; 133 152 134 134 - const execContentScript = (script, cb) => { 135 135 - const view = new BrowserView({ 136 136 - webPreferences: { 137 137 - preload: path.join(__dirname, 'preload.js'), 138 138 - // isolate content and do not persist it 139 139 - partition: Date.now() 140 140 - } 141 141 - }); 153 153 + const getData = () => { 154 154 + let rollup = { 155 155 + prefs: { 156 156 + schema: prefsSchema, 157 157 + data: appStore.get('prefs') 158 158 + }, 159 159 + features: [] 160 160 + }; 142 161 143 143 - view.webContents.send('window', { 144 144 - id: 'view', 145 145 - type: 'script', 146 146 - data: script 162 162 + Object.keys(features).forEach(k => { 163 163 + const feature = features[k]; 164 164 + rollup.features.push({ 165 165 + config: feature.config, 166 166 + labels: feature.labels, 167 167 + schemas: feature.schemas, 168 168 + data: feature.data 169 169 + }) 147 170 }); 148 171 149 149 - view.webContents.loadURL(script.address); 172 172 + return rollup; 173 173 + }; 174 174 + 175 175 + const updateData = newData => { 176 176 + console.log('updateData', newData); 150 177 151 151 - const str = ` 152 152 - const s = "${script.selector}"; 153 153 - const r = document.querySelector(s); 154 154 - const value = r ? r.textContent : null; 155 155 - value; 156 156 - `; 178 178 + if (newData.prefs) { 179 179 + appStore.set('prefs', newData.prefs); 180 180 + } 157 181 158 158 - view.webContents.on('dom-ready', async () => { 159 159 - try { 160 160 - const r = await view.webContents.executeJavaScript(str); 161 161 - cb(r); 162 162 - } catch(ex) { 163 163 - console.error('cs exec error', ex); 164 164 - cb(null); 182 182 + Object.keys(newData).forEach(k => { 183 183 + if (features[k]) { 184 184 + features[k].onChange(newData[k]); 165 185 } 166 186 }); 167 187 }; 168 188 169 169 - let _intervals = []; 189 189 + const prefsSchema = { 190 190 + "$schema": "https://json-schema.org/draft/2020-12/schema", 191 191 + "$id": "peek.prefs.schema.json", 192 192 + "title": "Peek - prefs", 193 193 + "description": "Peek user preferences", 194 194 + "type": "object", 195 195 + "properties": { 196 196 + "globalKeyCmd": { 197 197 + "description": "Global OS hotkey to load app", 198 198 + "type": "string", 199 199 + "default": "CommandOrControl+Escape" 200 200 + } 201 201 + }, 202 202 + "required": [ "globalKeyCmd" ] 203 203 + }; 170 204 171 171 - const initScripts = scripts => { 172 172 - //console.log('initScripts', scripts); 173 173 - 174 174 - // blow it all away for now 175 175 - // someday make it right proper just cancel/update changed and add new 176 176 - _intervals.forEach(clearInterval); 177 177 - 178 178 - // debounce me somehow so not shooting em all off 179 179 - // at once every time app starts 180 180 - scripts.forEach(script => { 181 181 - setInterval(() => { 182 182 - //console.log('interval hit', script.title); 183 183 - const r = execContentScript(script, (res) => { 184 184 - //console.log('cs r', res); 185 185 - 186 186 - if (script.previousValue != res) { 187 187 - // update stored value 188 188 - const previousValue = script.previousValue; 189 189 - script.previousValue = res; 190 190 - const idx = data.scripts.findIndex(el => el.id == script.id); 191 191 - if (idx >= 0) { 192 192 - data.scripts[idx] = script; 193 193 - set(data); 194 194 - } 195 195 - else { 196 196 - console.log('errrrr, wat'); 197 197 - } 198 198 - 199 199 - // notification 200 200 - // add to schema and support per script 201 201 - /* 202 202 - const title = `Peek :: Script :: ${script.title}`; 203 203 - const body = [ 204 204 - `Script result changed for ${script.title}:`, 205 205 - `- Old: ${previousValue}`, 206 206 - `- New: ${res}` 207 207 - ].join('\n'); 205 205 + const initPrefs = store => { 206 206 + const defaults = { 207 207 + globalKeyCmd: 'CommandOrControl+Escape', 208 208 + }; 208 209 209 209 - new Notification({ title, body }).show(); 210 210 - */ 211 211 - } 212 212 - }); 213 213 - }, script.interval); 214 214 - }); 215 215 - }; 210 210 + let prefs = appStore.get('prefs'); 211 211 + if (!prefs) { 212 212 + store.set('prefs', defaults); 213 213 + prefs = store.get('prefs'); 214 214 + } 216 215 217 217 - const initGlobalShortcuts = prefs => { 216 216 + // register global activation shortcut 218 217 if (globalShortcut.isRegistered(prefs.globalKeyCmd)) { 219 218 globalShortcut.unregister(prefs.globalKeyCmd); 220 219 } 221 220 222 222 - // register global activation shortcut 223 221 const onGlobalKeyCmd = () => getMainWindow().show(); 224 222 225 223 const ret = globalShortcut.register(prefs.globalKeyCmd, onGlobalKeyCmd); ··· 229 227 } 230 228 }; 231 229 232 232 - const showPeek = (peek) => { 233 233 - const height = peek.height || 600; 234 234 - const width = peek.width || 800; 235 235 - 236 236 - let win = null; 230 230 + const initFeatures = (features) => { 237 231 238 238 - const key = 'peek' + peek.keyNum; 232 232 + // TODO: allow features to register 233 233 + // as app level prefs for enable/disable 239 234 240 240 - if (_peekWins[key]) { 241 241 - console.log('peek', peek.keyNum, 'using stored window'); 242 242 - win = _peekWins[key]; 243 243 - win.show(); 244 244 - } 245 245 - else { 246 246 - console.log('peek', peek.keyNum, 'creating new window'); 247 247 - win = new BrowserWindow({ 248 248 - height, 249 249 - width, 250 250 - center: true, 251 251 - skipTaskbar: true, 252 252 - autoHideMenuBar: true, 253 253 - titleBarStyle: 'hidden', 254 254 - webPreferences: { 255 255 - preload: path.join(__dirname, 'preload.js'), 256 256 - // isolate content and do not persist it 257 257 - //partition: Date.now() 258 258 - } 259 259 - }); 260 260 - } 235 235 + // inject into features 236 236 + // eventually get to less tight coupling 237 237 + const api = { 238 238 + preloadPath, 239 239 + }; 261 240 262 262 - const onGoAway = () => { 263 263 - /* 264 264 - if (peek.keepLive) { 265 265 - _peekWins[key] = win; 266 266 - win.hide(); 267 267 - } 268 268 - else { 269 269 - win.destroy(); 270 270 - } 271 271 - */ 272 272 - win.destroy(); 273 273 - } 274 274 - win.on('blur', onGoAway); 275 275 - win.on('close', onGoAway); 241 241 + const featureContainerPrefix = 'peekFeature'; 276 242 277 277 - /* 278 278 - const str = ` 279 279 - window.addEventListener('keyup', e => { 280 280 - if (e.key == 'Escape') { 281 281 - console.log('peek script esc'); 282 282 - } 283 283 - }); 284 284 - 1; 285 285 - `; 243 243 + Object.keys(features).forEach(k => { 244 244 + const feature = features[k]; 245 245 + const storeName = `${featureContainerPrefix}${feature.labels.featureType}`; 286 246 287 287 - win.webContents.on('dom-ready', async () => { 288 288 - try { 289 289 - const r = await win.webContents.executeJavaScript(str); 290 290 - console.log(r); 291 291 - } catch(ex) { 292 292 - console.error('cs exec error', ex); 293 293 - } 294 294 - }); 295 295 - */ 296 296 - 297 297 - win.webContents.send('window', { 298 298 - path: path.join(__dirname), 299 299 - id: win.id, 300 300 - type: 'peek', 301 301 - data: peek 302 302 - }); 303 303 - 304 304 - win.loadURL(peek.address); 305 305 - }; 306 306 - 307 307 - const initPeeks = (cmdPrefix, peeks) => { 308 308 - peeks.forEach((p, i) => { 309 309 - if (globalShortcut.isRegistered(cmdPrefix + `${i}`)) { 310 310 - globalShortcut.unregister(cmdPrefix + `${i}`) 311 311 - } 312 312 - 313 313 - const ret = globalShortcut.register(cmdPrefix + `${i}`, () => { 314 314 - showPeek(p); 247 247 + // have to make per feature stores for now, pfftt 248 248 + // maybe fine, better isolation 249 249 + const featureStore = new Store({ 250 250 + name: storeName, 251 251 + // TODO: figure out schema approach here 252 252 + //schema: fullSchema, 253 253 + watch: true 315 254 }); 316 255 317 317 - if (!ret) { 318 318 - console.error('Unable to register peek'); 319 319 - } 320 320 - }); 321 321 - }; 322 322 - 323 323 - const animateSlide = (win, slide) => { 324 324 - return new Promise((res, rej) => { 325 325 - const { size, bounds } = screen.getPrimaryDisplay(); 326 326 - 327 327 - // get x/y field 328 328 - const coord = slide.screenEdge == 'Left' || slide.screenEdge == 'Right' ? 'x' : 'y'; 329 329 - 330 330 - const dim = coord == 'x' ? 'width' : 'height'; 331 331 - 332 332 - const winBounds = win.getBounds(); 333 333 - 334 334 - // created window at x/y taking animation into account 335 335 - let pos = winBounds[coord]; 336 336 - 337 337 - const speedMs = 150; 338 338 - const timerInterval = 10; 339 339 - 340 340 - let tick = 0; 341 341 - const numTicks = parseInt(speedMs / timerInterval); 342 342 - 343 343 - const offset = slide[dim] / numTicks; 344 344 - 345 345 - //console.log('numTicks', numTicks, 'widthChunk', offset); 346 346 - 347 347 - const timer = setInterval(() => { 348 348 - tick++; 349 349 - 350 350 - if (tick >= numTicks) { 351 351 - clearInterval(timer); 352 352 - res(); 353 353 - } 354 354 - 355 355 - const winBounds = win.getBounds(); 356 356 - 357 357 - if (slide.screenEdge == 'Right' || slide.screenEdge == 'Down') { 358 358 - // new position is current position +/- offset 359 359 - pos = pos - offset; 360 360 - } 361 361 - 362 362 - const grownEnough = winBounds[dim] <= slide[dim]; 363 363 - const newDim = grownEnough ? 364 364 - winBounds[dim] + offset 365 365 - : winBounds[dim]; 366 366 - 367 367 - const newBounds = {}; 368 368 - newBounds[coord] = parseInt(pos, 10); 369 369 - newBounds[dim] = parseInt(newDim, 10); 370 370 - 371 371 - // set new bounds 372 372 - win.setBounds(newBounds); 373 373 - 374 374 - }, timerInterval); 375 375 - }); 376 376 - }; 377 377 - 378 378 - const showSlide = (slide) => { 379 379 - let win = null; 380 380 - 381 381 - const key = 'slide' + slide.screenEdge; 382 382 - 383 383 - // TODO: fix stored+live windows 384 384 - if (_slideWins[key]) { 385 385 - console.log('slide', slide.screenEdge, 'using stored window'); 386 386 - win = _slideWins[key]; 387 387 - win.show(); 388 388 - } 389 389 - else { 390 390 - 391 391 - const { size, bounds } = screen.getPrimaryDisplay(); 392 392 - 393 393 - let x, y, height, width, center = null; 394 394 - 395 395 - switch(slide.screenEdge) { 396 396 - case 'Up': 397 397 - // horizontally center 398 398 - x = (size.width - slide.width) / 2; 399 399 - 400 400 - // y starts at screen top and stays there 401 401 - y = 0; 402 402 - 403 403 - width = slide.width; 404 404 - height = 1; 405 405 - break; 406 406 - case 'Down': 407 407 - // horizonally center 408 408 - x = (size.width - slide.width) / 2; 409 409 - 410 410 - // y ends up at window height from bottom 411 411 - // 412 412 - // eg: y = size.height - slide.height; 413 413 - // 414 414 - // but starts at screen bottom 415 415 - y = size.height; 416 416 - 417 417 - width = slide.width; 418 418 - height = 1; 419 419 - break; 420 420 - case 'Left': 421 421 - // x starts and ends at at left screen edge 422 422 - // at left edge 423 423 - x = 0; 424 424 - 425 425 - // vertically center 426 426 - y = (size.height - slide.height) / 2; 427 427 - 428 428 - width = 1; 429 429 - height = slide.height; 430 430 - break; 431 431 - case 'Right': 432 432 - // x ends at at right screen edge - window size 433 433 - // 434 434 - // eg: x = size.width - slide.width; 435 435 - // 436 436 - // but starts at screen right edge, will animate in 437 437 - x = size.width; 438 438 - 439 439 - // vertically center 440 440 - y = (size.height - slide.height) / 2; 441 441 - 442 442 - width = 1; 443 443 - height = slide.height; 444 444 - break; 445 445 - default: 446 446 - center = true; 447 447 - console.log('waddafa'); 448 448 - } 449 449 - 450 450 - win = new BrowserWindow({ 451 451 - height, 452 452 - width, 453 453 - x, 454 454 - y, 455 455 - skipTaskbar: true, 456 456 - autoHideMenuBar: true, 457 457 - titleBarStyle: 'hidden', 458 458 - // maybe worth doing instead of animating width 459 459 - //enableLargerThanScreen: true, 460 460 - webPreferences: { 461 461 - preload: path.join(__dirname, 'preload.js'), 462 462 - // isolate content and do not persist it 463 463 - partition: Date.now() 464 464 - } 256 256 + featureStore.onDidAnyChange(newData => { 257 257 + initData(); 258 258 + //win.webContents.send('configchange', {}); 465 259 }); 466 260 467 467 - //_slideWins[key] = win; 468 468 - } 469 469 - 470 470 - animateSlide(win, slide).then(); 471 471 - 472 472 - const onGoAway = () => { 473 473 - /* 474 474 - if (slide.keepLive) { 475 475 - _slideWins[key] = win; 476 476 - win.hide(); 477 477 - } 478 478 - else { 479 479 - win.destroy(); 480 480 - } 481 481 - */ 482 482 - win.destroy(); 483 483 - } 484 484 - win.on('blur', onGoAway); 485 485 - win.on('close', onGoAway); 486 486 - 487 487 - /* 488 488 - const str = ` 489 489 - window.addEventListener('keyup', e => { 490 490 - if (e.key == 'Escape') { 491 491 - console.log('peek script esc'); 492 492 - } 493 493 - }); 494 494 - 1; 495 495 - `; 496 496 - 497 497 - win.webContents.on('dom-ready', async () => { 498 498 - try { 499 499 - const r = await win.webContents.executeJavaScript(str); 500 500 - console.log(r); 501 501 - } catch(ex) { 502 502 - console.error('cs exec error', ex); 503 503 - } 504 504 - }); 505 505 - */ 506 506 - 507 507 - win.webContents.send('window', { 508 508 - path: path.join(__dirname), 509 509 - id: win.id, 510 510 - type: 'slide', 511 511 - data: slide 512 512 - }); 513 513 - 514 514 - //win.setBounds({ x: 0, y: 0, width, height }) 515 515 - win.loadURL(slide.address); 516 516 - }; 517 517 - 518 518 - const initSlides = (cmdPrefix, slides) => { 519 519 - slides.forEach(s => { 520 520 - if (!globalShortcut.isRegistered(cmdPrefix + `${s.screenEdge}`)) { 521 521 - const ret = globalShortcut.register(cmdPrefix + `${s.screenEdge}`, () => { 522 522 - showSlide(s); 523 523 - }); 524 524 - 525 525 - if (!ret) { 526 526 - console.error('Unable to register slide'); 527 527 - } 528 528 - } 261 261 + feature.init(api, featureStore); 529 262 }); 530 263 }; 531 264 532 265 // initialized all bits which need updating if the data changes 533 266 // can be called repeatedly to refresh on changes 534 534 - const initData = data => { 535 535 - // initialize prefs 536 536 - const prefs = data.prefs; 537 537 - initGlobalShortcuts(prefs); 267 267 + const initData = () => { 268 268 + // initialize app prefs 269 269 + initPrefs(appStore); 538 270 539 539 - // initialize peeks 540 540 - if (data.peeks.length > 0) { 541 541 - initPeeks(prefs.peekKeyPrefix, data.peeks); 542 542 - } 271 271 + initFeatures(features); 543 272 273 273 + /* 544 274 // initialize slides 545 275 if (data.slides.length > 0) { 546 276 initSlides(prefs.slideKeyPrefix, data.slides); ··· 550 280 if (data.scripts.length > 0) { 551 281 initScripts(data.scripts); 552 282 } 283 283 + */ 553 284 }; 554 285 286 286 + const appStore = new Store({ 287 287 + name: labels.app.key, 288 288 + // TODO: re-enable schemas 289 289 + //schema: fullSchema, 290 290 + watch: true 291 291 + }); 292 292 + 293 293 + // DEBUG 294 294 + appStore.clear(); 295 295 + 555 296 // app load 556 297 const onReady = () => { 557 298 console.log('onReady'); 299 299 + 558 300 // create main app window on app start 559 301 const win = getMainWindow(); 560 560 - 561 561 - win.webContents.send('window', { 562 562 - path: path.join(__dirname), 563 563 - id: win.id, 564 564 - type: 'main', 565 565 - }); 566 566 - 567 567 - initData(data); 568 302 569 303 // keep app out of dock and tab switcher 570 304 if (app.dock) { ··· 573 307 574 308 initTray(); 575 309 576 576 - watch(newData => { 577 577 - initData(newData); 310 310 + initData(); 311 311 + 312 312 + appStore.onDidAnyChange(newData => { 313 313 + initData(); 578 314 win.webContents.send('configchange', {}); 579 315 }); 580 316 }; ··· 582 318 app.whenReady().then(onReady); 583 319 584 320 // when renderer is ready, send over user data 585 585 - ipcMain.on('getconfig', () => { 586 586 - getMainWindow().webContents.send('config', { 587 587 - data, 588 588 - schemas 589 589 - }); 321 321 + ipcMain.on('getconfig', (ev, data) => { 322 322 + getMainWindow().webContents.send('config', getData()) 590 323 }); 591 324 592 325 // listen for updates ··· 594 327 // TODO: if any shortcuts changed, unregister the old ones 595 328 596 329 // write to datastore 597 597 - set(newData); 330 330 + updateData(newData); 598 331 }); 599 332 600 333 // ipc ESC handler 601 334 ipcMain.on('esc', (event, title) => { 602 335 console.log('esc'); 603 603 - const win = getMainWindow(); 336 336 + 337 337 + const fwin = BrowserWindow.getFocusedWindow(); 338 338 + 604 339 // 605 605 - if (!win.isDestroyed()) { 340 340 + if (!fwin.isDestroyed()) { 606 341 console.log('esc: killingit'); 607 607 - win.close(); 608 608 - win.destroy(); 609 609 - _win = null; 342 342 + fwin.close(); 343 343 + //win.destroy(); 344 344 + //_win = null; 610 345 } 611 346 // 612 347 /* ··· 628 363 _win.destroy(); 629 364 _win = null; 630 365 } 631 631 - // 366 366 + /* 632 367 if (_win.isVisible()) { 633 368 console.log('win is visible, hide it'); 634 369 //_win.hide(); 635 370 } 636 636 - else if (process.platform !== 'darwin') { 371 371 + */ 372 372 + 373 373 + if (process.platform !== 'darwin') { 637 374 onQuit(); 638 375 } 639 376 });

+37 -19

preload.js

reviewed

··· 13 13 } 14 14 }); 15 15 16 16 + 16 17 // all window types close on escape 17 18 window.addEventListener('keyup', e => { 18 19 if (e.key == 'Escape') { ··· 20 21 } 21 22 }); 22 23 23 23 - const handleMainWindow = () => { 24 24 - let api = {}; 24 24 + let api = {}; 25 25 26 26 - api.onConfigChange = callback => { 27 27 - ipcRenderer.on('configchange', (ev, msg) => { 28 28 - callback(msg); 29 29 - }); 30 30 - }; 26 26 + api.onConfigChange = callback => { 27 27 + // noop if not an internal app file 28 28 + const isMain = window.location.protocol == 'file:'; 29 29 + if (!isMain) { 30 30 + return; 31 31 + } 31 32 32 32 - api.getConfig = new Promise((resolve, reject) => { 33 33 - // TODO: race potential 34 34 - ipcRenderer.once('config', (ev, msg) => { 35 35 - resolve(msg); 36 36 - }); 37 37 - ipcRenderer.send('getconfig'); 33 33 + ipcRenderer.on('configchange', (ev, msg) => { 34 34 + callback(msg); 38 35 }); 36 36 + }; 39 37 40 40 - api.setConfig = cfg => { 41 41 - //console.log('preload: setConfig', cfg); 42 42 - ipcRenderer.send('setconfig', cfg); 43 43 - }; 38 38 + api.getConfig = new Promise((resolve, reject) => { 39 39 + // noop if not an internal app file 40 40 + const isMain = window.location.protocol == 'file:'; 41 41 + if (!isMain) { 42 42 + return; 43 43 + } 44 44 45 45 - contextBridge.exposeInMainWorld('app', api); 45 45 + // TODO: race potential 46 46 + ipcRenderer.once('config', (ev, msg) => { 47 47 + resolve(msg); 48 48 + }); 49 49 + ipcRenderer.send('getconfig', {isMain}); 50 50 + }); 46 51 47 47 - window.addEventListener('DOMContentLoaded', () => { 52 52 + api.setConfig = cfg => { 53 53 + // noop if not an internal app file 54 54 + const isMain = window.location.protocol == 'file:'; 55 55 + if (!isMain) { 56 56 + return; 57 57 + } 58 58 + 59 59 + ipcRenderer.send('setconfig', cfg); 60 60 + }; 61 61 + 62 62 + contextBridge.exposeInMainWorld('app', api); 63 63 + 64 64 + const handleMainWindow = () => { 65 65 + window.addEventListener('load', () => { 48 66 const replaceText = (selector, text) => { 49 67 const element = document.getElementById(selector) 50 68 if (element) element.innerText = text

+50 -44

renderer.js

reviewed

··· 5 5 prefs: { 6 6 paneTitle: 'Preferences', 7 7 globalKeyCmd: 'App activation shortcut', 8 8 - peekKeyPrefix: 'Peek shortcut prefix', 9 9 - slideKeyPrefix: 'Slide shortcut prefix', 10 8 }, 9 9 + /* 11 10 peeks: { 12 11 paneTitle: 'Peeks', 13 12 type: 'Peek', ··· 24 23 addBtn: 'Add', 25 24 delBtn: 'Delete', 26 25 } 26 26 + */ 27 27 }; 28 28 29 29 // TODO: capture and internally navigate out of panes ··· 48 48 console.log('renderer: init'); 49 49 console.log('renderer: cfg', cfg); 50 50 51 51 - let { data, schemas } = cfg; 51 51 + let { prefs, features } = cfg; 52 52 + 52 53 const containerEl = document.querySelector('.houseofpane'); 53 54 54 55 // blow away panes if this is an update ··· 59 60 panes = []; 60 61 } 61 62 62 62 - // janky but hey it all is soooo 63 63 - const initPane = (type) => { 63 63 + // prefs pane 64 64 + const el = containerEl.querySelector('.prefs'); 65 65 + const onChange = newData => { 66 66 + updateToMain({ prefs: newData }); 67 67 + }; 68 68 + 69 69 + const prefsPane = initValuesPane( 70 70 + el, 71 71 + labels.prefs, 72 72 + cfg.prefs.schema, 73 73 + cfg.prefs.data, 74 74 + onChange); 75 75 + panes.push({ el, pane: prefsPane }); 76 76 + 77 77 + cfg.features.forEach(feature => { 78 78 + const type = feature.labels.featureType; 64 79 const el = containerEl.querySelector('.' + type); 65 80 66 66 - const initPane = type == 'prefs' ? initValuesPane : initListPane; 67 67 - 68 68 - const allowNew = type == 'scripts' || false; 81 81 + const allowNew = feature.config.allowNew || false; 82 82 + const disabled = feature.config.disabled || []; 69 83 84 84 + /* 70 85 const disabled = { 71 71 - prefs: [], 72 86 scripts: ['previousValue'], 73 73 - peeks: ['keyNum'], 74 87 slides: ['screenEdge'], 75 88 }; 76 76 - 77 77 - const labelMaker = entry => { 78 78 - if (type == 'peeks') { 79 79 - return `${data.prefs.peekKeyPrefix}${entry.keyNum} - ${entry.address}`; 80 80 - } 81 81 - else if (type == 'slides') { 82 82 - return `${entry.screenEdge} - ${entry.address}`; 83 83 - } 84 84 - return entry.title; 85 85 - }; 89 89 + */ 86 90 87 91 const onChange = newData => { 88 88 - data[type] = newData; 89 89 - updateToMain(data); 92 92 + const p = {}; 93 93 + p[type] = { items: newData }; 94 94 + updateToMain(p); 90 95 }; 91 96 92 92 - const pane = initPane( 97 97 + const pane = initFeaturePane( 93 98 el, 94 94 - labels[type], 95 95 - schemas[type], 96 96 - data[type], 97 97 - onChange, 98 98 - allowNew, 99 99 - disabled[type], 100 100 - labelMaker 99 99 + feature, 100 100 + onChange 101 101 ); 102 102 103 103 panes.push({ 104 104 el, 105 105 pane 106 106 }); 107 107 - }; 108 108 - 109 109 - ['prefs', 'peeks', 'slides', 'scripts'].forEach(initPane); 107 107 + }); 110 108 }; 111 109 112 110 const fillPaneFromSchema = (pane, labels, schema, data, onChange, disabled) => { ··· 135 133 } 136 134 137 135 params[k] = v; 136 136 + 138 137 const input = pane.addInput(params, k, opts); 139 138 // TODO: consider inline state management 140 139 input.on('change', ev => { ··· 179 178 return val; 180 179 }; 181 180 182 182 - const initValuesPane = (container, labels, schema, values, onChange, allowNew, disabled, labelMaker) => { 181 181 + const initValuesPane = (container, labels, schema, values, onChange) => { 183 182 const pane = new Tweakpane.Pane({ 184 183 container: container, 185 184 title: labels.paneTitle 186 185 }); 187 186 188 188 - fillPaneFromSchema(pane, labels, schema, values, onChange, disabled); 187 187 + fillPaneFromSchema(pane, labels, schema, values, onChange, []); 189 188 190 189 const update = (ev) => { 191 190 // TODO: this won't work forever ··· 201 200 return pane; 202 201 }; 203 202 204 204 - const initListPane = (container, labels, schema, items, onChange, allowNew, disabled, labelMaker) => { 203 203 + const initFeaturePane = (container, feature, onChange) => { 204 204 + const { config, labels, schemas, data } = feature; 205 205 + 205 206 const pane = new Tweakpane.Pane({ 206 207 container: container, 207 207 - title: labels.paneTitle 208 208 + title: labels.featureDisplay 208 209 }); 209 210 210 211 const update = (all) => { ··· 216 217 onChange(newData); 217 218 }; 218 219 219 219 - items.forEach(entry => { 220 220 + // add prefs 221 221 + 222 222 + // add items 223 223 + data.items.forEach(item => { 220 224 const folder = pane.addFolder({ 221 221 - title: labelMaker(entry), 225 225 + title: item.title, 222 226 expanded: false 223 227 }); 224 228 225 225 - fillPaneFromSchema(folder, labels, schema, entry, onChange, disabled); 229 229 + fillPaneFromSchema(folder, labels, schemas.item, item, onChange, config.disabled); 226 230 227 231 // TODO: implement 228 228 - folder.addButton({title: labels.testBtn}); 232 232 + //folder.addButton({title: labels.testBtn}); 229 233 230 230 - if (allowNew) { 234 234 + if (config.allowNew) { 231 235 const delBtn = folder.addButton({title: labels.delBtn}); 232 236 delBtn.on('click', () => { 233 237 pane.remove(folder); ··· 236 240 }); 237 241 } 238 242 239 239 - folder.on('change', () => update()); 243 243 + folder.on('change', () => update(!config.allowNew)); 240 244 }); 241 245 242 242 - if (allowNew) { 246 246 + /* 247 247 + if (config.allowNew) { 243 248 // add new item entry 244 249 const folder = pane.addFolder({ 245 250 title: labels.newFolder, ··· 256 261 update(true); 257 262 }); 258 263 } 264 264 + */ 259 265 260 266 return pane; 261 267 };

-5

scripts.js

reviewed

··· 1 1 - // Manage content script execution 2 2 - 3 3 - const manager = { 4 4 - 5 5 - };