Download ext/wasm/fiddle/fiddle.js from AryaWu/sqlite: direct link, hf CLI and curl.
- Browser
- Download file 34.2 kB
-
https://huggingface.co/AryaWu/sqlite/resolve/main/ext/wasm/fiddle/fiddle.js
- Command line
-
hf download hf://AryaWu/sqlite/ext/wasm/fiddle/fiddle.js
-
curl -L -o fiddle.js https://huggingface.co/AryaWu/sqlite/resolve/main/ext/wasm/fiddle/fiddle.js
34.2 kB
| /* | |
| 2022-05-20 | |
| The author disclaims copyright to this source code. In place of a | |
| legal notice, here is a blessing: | |
| * May you do good and not evil. | |
| * May you find forgiveness for yourself and forgive others. | |
| * May you share freely, never taking more than you give. | |
| *********************************************************************** | |
| This is the main entry point for the sqlite3 fiddle app. It sets up the | |
| various UI bits, loads a Worker for the db connection, and manages the | |
| communication between the UI and worker. | |
| */ | |
| (function(){ | |
| 'use strict'; | |
| /* Recall that the 'self' symbol, except where locally | |
| overwritten, refers to the global window or worker object. */ | |
| const storage = (function(NS/*namespace object in which to store this module*/){ | |
| /* Pedantic licensing note: this code originated in the Fossil SCM | |
| source tree, where it has a different license, but the person who | |
| ported it into sqlite is the same one who wrote it for fossil. */ | |
| 'use strict'; | |
| NS = NS||{}; | |
| /** | |
| This module provides a basic wrapper around localStorage | |
| or sessionStorage or a dummy proxy object if neither | |
| of those are available. | |
| */ | |
| const tryStorage = function f(obj){ | |
| if(!f.key) f.key = 'storage.access.check'; | |
| try{ | |
| obj.setItem(f.key, 'f'); | |
| const x = obj.getItem(f.key); | |
| obj.removeItem(f.key); | |
| if(x!=='f') throw new Error(f.key+" failed") | |
| return obj; | |
| }catch(e){ | |
| return undefined; | |
| } | |
| }; | |
| /** Internal storage impl for this module. */ | |
| const $storage = | |
| tryStorage(window.localStorage) | |
| || tryStorage(window.sessionStorage) | |
| || tryStorage({ | |
| // A basic dummy xyzStorage stand-in | |
| $$$:{}, | |
| setItem: function(k,v){this.$$$[k]=v}, | |
| getItem: function(k){ | |
| return this.$$$.hasOwnProperty(k) ? this.$$$[k] : undefined; | |
| }, | |
| removeItem: function(k){delete this.$$$[k]}, | |
| clear: function(){this.$$$={}} | |
| }); | |
| /** | |
| For the dummy storage we need to differentiate between | |
| $storage and its real property storage for hasOwnProperty() | |
| to work properly... | |
| */ | |
| const $storageHolder = $storage.hasOwnProperty('$$$') ? $storage.$$$ : $storage; | |
| /** | |
| A prefix which gets internally applied to all storage module | |
| property keys so that localStorage and sessionStorage across the | |
| same browser profile instance do not "leak" across multiple apps | |
| being hosted by the same origin server. Such cross-polination is | |
| still there but, with this key prefix applied, it won't be | |
| immediately visible via the storage API. | |
| With this in place we can justify using localStorage instead of | |
| sessionStorage. | |
| One implication of using localStorage and sessionStorage is that | |
| their scope (the same "origin" and client application/profile) | |
| allows multiple apps on the same origin to use the same | |
| storage. Thus /appA/foo could then see changes made via | |
| /appB/foo. The data do not cross user- or browser boundaries, | |
| though, so it "might" arguably be called a | |
| feature. storageKeyPrefix was added so that we can sandbox that | |
| state for each separate app which shares an origin. | |
| See: https://fossil-scm.org/forum/forumpost/4afc4d34de | |
| Sidebar: it might seem odd to provide a key prefix and stick all | |
| properties in the topmost level of the storage object. We do that | |
| because adding a layer of object to sandbox each app would mean | |
| (de)serializing that whole tree on every storage property change. | |
| e.g. instead of storageObject.projectName.foo we have | |
| storageObject[storageKeyPrefix+'foo']. That's soley for | |
| efficiency's sake (in terms of battery life and | |
| environment-internal storage-level effort). | |
| */ | |
| const storageKeyPrefix = ( | |
| $storageHolder===$storage/*localStorage or sessionStorage*/ | |
| ? ( | |
| (NS.config ? | |
| (NS.config.projectCode || NS.config.projectName | |
| || NS.config.shortProjectName) | |
| : false) | |
| || window.location.pathname | |
| )+'::' : ( | |
| '' /* transient storage */ | |
| ) | |
| ); | |
| /** | |
| A proxy for localStorage or sessionStorage or a | |
| page-instance-local proxy, if neither one is available. | |
| Which exact storage implementation is uses is unspecified, and | |
| apps must not rely on it. | |
| */ | |
| NS.storage = { | |
| storageKeyPrefix: storageKeyPrefix, | |
| /** Sets the storage key k to value v, implicitly converting | |
| it to a string. */ | |
| set: (k,v)=>$storage.setItem(storageKeyPrefix+k,v), | |
| /** Sets storage key k to JSON.stringify(v). */ | |
| setJSON: (k,v)=>$storage.setItem(storageKeyPrefix+k,JSON.stringify(v)), | |
| /** Returns the value for the given storage key, or | |
| dflt if the key is not found in the storage. */ | |
| get: (k,dflt)=>$storageHolder.hasOwnProperty( | |
| storageKeyPrefix+k | |
| ) ? $storage.getItem(storageKeyPrefix+k) : dflt, | |
| /** Returns true if the given key has a value of "true". If the | |
| key is not found, it returns true if the boolean value of dflt | |
| is "true". (Remember that JS persistent storage values are all | |
| strings.) */ | |
| getBool: function(k,dflt){ | |
| return 'true'===this.get(k,''+(!!dflt)); | |
| }, | |
| /** Returns the JSON.parse()'d value of the given | |
| storage key's value, or dflt is the key is not | |
| found or JSON.parse() fails. */ | |
| getJSON: function f(k,dflt){ | |
| try { | |
| const x = this.get(k,f); | |
| return x===f ? dflt : JSON.parse(x); | |
| } | |
| catch(e){return dflt} | |
| }, | |
| /** Returns true if the storage contains the given key, | |
| else false. */ | |
| contains: (k)=>$storageHolder.hasOwnProperty(storageKeyPrefix+k), | |
| /** Removes the given key from the storage. Returns this. */ | |
| remove: function(k){ | |
| $storage.removeItem(storageKeyPrefix+k); | |
| return this; | |
| }, | |
| /** Clears ALL keys from the storage. Returns this. */ | |
| clear: function(){ | |
| this.keys().forEach((k)=>$storage.removeItem(/*w/o prefix*/k)); | |
| return this; | |
| }, | |
| /** Returns an array of all keys currently in the storage. */ | |
| keys: ()=>Object.keys($storageHolder).filter((v)=>(v||'').startsWith(storageKeyPrefix)), | |
| /** Returns true if this storage is transient (only available | |
| until the page is reloaded), indicating that fileStorage | |
| and sessionStorage are unavailable. */ | |
| isTransient: ()=>$storageHolder!==$storage, | |
| /** Returns a symbolic name for the current storage mechanism. */ | |
| storageImplName: function(){ | |
| if($storage===window.localStorage) return 'localStorage'; | |
| else if($storage===window.sessionStorage) return 'sessionStorage'; | |
| else return 'transient'; | |
| }, | |
| /** | |
| Returns a brief help text string for the currently-selected | |
| storage type. | |
| */ | |
| storageHelpDescription: function(){ | |
| return { | |
| localStorage: "Browser-local persistent storage with an "+ | |
| "unspecified long-term lifetime (survives closing the browser, "+ | |
| "but maybe not a browser upgrade).", | |
| sessionStorage: "Storage local to this browser tab, "+ | |
| "lost if this tab is closed.", | |
| "transient": "Transient storage local to this invocation of this page." | |
| }[this.storageImplName()]; | |
| } | |
| }; | |
| return NS.storage; | |
| })({})/*storage API setup*/; | |
| /** Name of the stored copy of SqliteFiddle.config. */ | |
| const configStorageKey = 'sqlite3-fiddle-config'; | |
| /** | |
| The SqliteFiddle object is intended to be the primary | |
| app-level object for the main-thread side of the sqlite | |
| fiddle application. It uses a worker thread to load the | |
| sqlite WASM module and communicate with it. | |
| */ | |
| const SF/*local convenience alias*/ | |
| = window.SqliteFiddle/*canonical name*/ = { | |
| /* Config options. */ | |
| config: { | |
| /* If true, SqliteFiddle.echo() will auto-scroll the | |
| output widget to the bottom when it receives output, | |
| else it won't. */ | |
| autoScrollOutput: true, | |
| /* If true, the output area will be cleared before each | |
| command is run, else it will not. */ | |
| autoClearOutput: false, | |
| /* If true, SqliteFiddle.echo() will echo its output to | |
| the console, in addition to its normal output widget. | |
| That slows it down but is useful for testing. */ | |
| echoToConsole: false, | |
| /* If true, display input/output areas side-by-side. */ | |
| sideBySide: true, | |
| /* If true, swap positions of the input/output areas. */ | |
| swapInOut: false | |
| }, | |
| /** | |
| Emits the given text, followed by a line break, to the | |
| output widget. If given more than one argument, they are | |
| join()'d together with a space between each. As a special | |
| case, if passed a single array, that array is used in place | |
| of the arguments array (this is to facilitate receiving | |
| lists of arguments via worker events). | |
| */ | |
| echo: function f(text) { | |
| /* Maintenance reminder: we currently require/expect a textarea | |
| output element. It might be nice to extend this to behave | |
| differently if the output element is a non-textarea element, | |
| in which case it would need to append the given text as a TEXT | |
| node and add a line break. */ | |
| if(!f._){ | |
| f._ = document.getElementById('output'); | |
| f._.value = ''; // clear browser cache | |
| } | |
| if(arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' '); | |
| else if(1===arguments.length && Array.isArray(text)) text = text.join(' '); | |
| // These replacements are necessary if you render to raw HTML | |
| //text = text.replace(/&/g, "&"); | |
| //text = text.replace(/</g, "<"); | |
| //text = text.replace(/>/g, ">"); | |
| //text = text.replace('\n', '<br>', 'g'); | |
| if(null===text){/*special case: clear output*/ | |
| f._.value = ''; | |
| return; | |
| }else if(this.echo._clearPending){ | |
| delete this.echo._clearPending; | |
| f._.value = ''; | |
| } | |
| if(this.config.echoToConsole) console.log(text); | |
| if(this.jqTerm) this.jqTerm.echo(text); | |
| f._.value += text + "\n"; | |
| if(this.config.autoScrollOutput){ | |
| f._.scrollTop = f._.scrollHeight; | |
| } | |
| }, | |
| _msgMap: {}, | |
| /** Adds a worker message handler for messages of the given | |
| type. */ | |
| addMsgHandler: function f(type,callback){ | |
| if(Array.isArray(type)){ | |
| type.forEach((t)=>this.addMsgHandler(t, callback)); | |
| return this; | |
| } | |
| (this._msgMap.hasOwnProperty(type) | |
| ? this._msgMap[type] | |
| : (this._msgMap[type] = [])).push(callback); | |
| return this; | |
| }, | |
| /** Given a worker message, runs all handlers for msg.type. */ | |
| runMsgHandlers: function(msg){ | |
| const list = (this._msgMap.hasOwnProperty(msg.type) | |
| ? this._msgMap[msg.type] : false); | |
| if(!list){ | |
| console.warn("No handlers found for message type:",msg); | |
| return false; | |
| } | |
| //console.debug("runMsgHandlers",msg); | |
| list.forEach((f)=>f(msg)); | |
| return true; | |
| }, | |
| /** Removes all message handlers for the given message type. */ | |
| clearMsgHandlers: function(type){ | |
| delete this._msgMap[type]; | |
| return this; | |
| }, | |
| /* Posts a message in the form {type, data} to the db worker. Returns this. */ | |
| wMsg: function(type,data,transferables){ | |
| this.worker.postMessage({type, data}, transferables || []); | |
| return this; | |
| }, | |
| /** | |
| Prompts for confirmation and, if accepted, deletes | |
| all content and tables in the (transient) database. | |
| */ | |
| resetDb: function(){ | |
| if(window.confirm("Really destroy all content and tables " | |
| +"in the (transient) db?")){ | |
| this.wMsg('db-reset'); | |
| } | |
| return this; | |
| }, | |
| /** Stores this object's config in the browser's storage. */ | |
| storeConfig: function(){ | |
| storage.setJSON(configStorageKey,this.config); | |
| } | |
| }; | |
| if(1){ /* Restore SF.config */ | |
| const storedConfig = storage.getJSON(configStorageKey); | |
| if(storedConfig){ | |
| /* Copy all properties to SF.config which are currently in | |
| storedConfig. We don't bother copying any other | |
| properties: those have been removed from the app in the | |
| meantime. */ | |
| Object.keys(SF.config).forEach(function(k){ | |
| if(storedConfig.hasOwnProperty(k)){ | |
| SF.config[k] = storedConfig[k]; | |
| } | |
| }); | |
| } | |
| } | |
| SF.worker = new Worker('fiddle-worker.js'+self.location.search); | |
| SF.worker.onmessage = (ev)=>SF.runMsgHandlers(ev.data); | |
| SF.addMsgHandler(['stdout', 'stderr'], (ev)=>SF.echo(ev.data)); | |
| SF.addMsgHandler('sqlite-version', (ev)=>{ | |
| const v = ev.data; | |
| const a = E('#sqlite-version-link'); | |
| const li = v.srcId.split(' ')/*DATE TIME HASH*/; | |
| a.setAttribute('href', | |
| //'https://sqlite.org/src/timeline/?c='+li[2].substr(0,20) | |
| 'https://sqlite.org/src/info/'+li[2].substr(0,20) | |
| ); | |
| a.setAttribute('target', '_blank'); | |
| a.innerText = [ | |
| v.lib, | |
| v.srcId.substr(0,34) | |
| ].join(' '); | |
| SF.echo("SQLite version",a.innerText); | |
| }); | |
| SF.addMsgHandler('wasm-info', (ev)=>{ | |
| const v = ev.data; | |
| SF.e.wasmInfo.innerText = 'WASM: '+( | |
| 4===v.pointerSize ? 32 : 64 | |
| )+'-bit' | |
| //+' heap size: '+Number(v.heapSize) | |
| // Heap size is not changing even when loading a huge db? | |
| ; | |
| }); | |
| /* querySelectorAll() proxy */ | |
| const EAll = function(/*[element=document,] cssSelector*/){ | |
| return (arguments.length>1 ? arguments[0] : document) | |
| .querySelectorAll(arguments[arguments.length-1]); | |
| }; | |
| /* querySelector() proxy */ | |
| const E = function(/*[element=document,] cssSelector*/){ | |
| return (arguments.length>1 ? arguments[0] : document) | |
| .querySelector(arguments[arguments.length-1]); | |
| }; | |
| /** Handles status updates from the Emscripten Module object. */ | |
| SF.addMsgHandler('module', function f(ev){ | |
| ev = ev.data; | |
| if('status'!==ev.type){ | |
| console.warn("Unexpected module-type message:",ev); | |
| return; | |
| } | |
| if(!f.ui){ | |
| f.ui = { | |
| status: E('#module-status'), | |
| progress: E('#module-progress'), | |
| spinner: E('#module-spinner') | |
| }; | |
| } | |
| const msg = ev.data; | |
| if(f.ui.progres){ | |
| progress.value = msg.step; | |
| progress.max = msg.step + 1/*we don't know how many steps to expect*/; | |
| } | |
| if(1==msg.step){ | |
| f.ui.progress.classList.remove('hidden'); | |
| f.ui.spinner.classList.remove('hidden'); | |
| } | |
| if(msg.text){ | |
| f.ui.status.classList.remove('hidden'); | |
| f.ui.status.innerText = msg.text; | |
| }else{ | |
| if(f.ui.progress){ | |
| f.ui.progress.remove(); | |
| f.ui.spinner.remove(); | |
| delete f.ui.progress; | |
| delete f.ui.spinner; | |
| } | |
| f.ui.status.classList.add('hidden'); | |
| /* The module can post messages about fatal problems, | |
| e.g. an exit() being triggered or assertion failure, | |
| after the last "load" message has arrived, so | |
| leave f.ui.status and message listener intact. */ | |
| } | |
| }); | |
| /** | |
| The 'fiddle-ready' event is fired (with no payload) when the | |
| wasm module has finished loading. Interestingly, that happens | |
| _before_ the final module:status event */ | |
| SF.addMsgHandler('fiddle-ready', function(){ | |
| SF.clearMsgHandlers('fiddle-ready'); | |
| self.onSFLoaded(); | |
| }); | |
| SF.e ={ | |
| about: E('#view-about'), | |
| split: E('#view-split'), | |
| wasmInfo: E('#opt-wasm-info'), | |
| terminal: E('#view-terminal'), | |
| hideInTerminal: EAll('.hide-in-terminal' | |
| /* Elements to hide when in terminal mode */) | |
| }; | |
| SF.eViews = EAll('.app-view'); | |
| SF.setMainView = function(eMain){ | |
| if( SF.e.main === eMain ) return; | |
| SF.eViews.forEach((e)=>{ | |
| if( e===eMain ) e.classList.remove('hidden'); | |
| else e.classList.add('hidden'); | |
| }); | |
| SF.e.hideInTerminal.forEach(e=>{ | |
| if( eMain === SF.e.terminal ) e.classList.add('hidden'); | |
| else e.classList.remove('hidden'); | |
| }); | |
| SF.e.main = eMain; | |
| SF.ForceResizeKludge(); | |
| }; | |
| /** Toggle the "About" view on and off. */ | |
| SF.toggleAbout = function(){ | |
| if( SF.e.about.classList.contains('hidden') ){ | |
| SF.e.about.$returnTo = SF.e.main; | |
| SF.setMainView( SF.e.about ); | |
| }else{ | |
| const e = SF.e.about.$returnTo; | |
| delete SF.e.about.$returnTo; | |
| SF.setMainView( e ); | |
| } | |
| }; | |
| /** | |
| Given a DOM element, this routine measures its "effective | |
| height", which is the bounding top/bottom range of this element | |
| and all of its children, recursively. For some DOM structure | |
| cases, a parent may have a reported height of 0 even though | |
| children have non-0 sizes. | |
| Returns 0 if !e or if the element really has no height. | |
| */ | |
| const effectiveHeight = function f(e){ | |
| if(!e) return 0; | |
| if(!f.measure){ | |
| f.measure = function callee(e, depth){ | |
| if(!e) return; | |
| const m = e.getBoundingClientRect(); | |
| if(0===depth){ | |
| callee.top = m.top; | |
| callee.bottom = m.bottom; | |
| }else{ | |
| callee.top = m.top ? Math.min(callee.top, m.top) : callee.top; | |
| callee.bottom = Math.max(callee.bottom, m.bottom); | |
| } | |
| Array.prototype.forEach.call(e.children,(e)=>callee(e,depth+1)); | |
| if(0===depth){ | |
| //console.debug("measure() height:",e.className, callee.top, callee.bottom, (callee.bottom - callee.top)); | |
| f.extra += callee.bottom - callee.top; | |
| } | |
| return f.extra; | |
| }; | |
| } | |
| f.extra = 0; | |
| f.measure(e,0); | |
| return f.extra; | |
| }; | |
| /** | |
| Returns a function, that, as long as it continues to be invoked, | |
| will not be triggered. The function will be called after it stops | |
| being called for N milliseconds. If `immediate` is passed, call | |
| the callback immediately and hinder future invocations until at | |
| least the given time has passed. | |
| If passed only 1 argument, or passed a falsy 2nd argument, | |
| the default wait time set in this function's $defaultDelay | |
| property is used. | |
| Source: underscore.js, by way of https://davidwalsh.name/javascript-debounce-function | |
| */ | |
| const debounce = function f(func, wait, immediate) { | |
| var timeout; | |
| if(!wait) wait = f.$defaultDelay; | |
| return function() { | |
| const context = this, args = Array.prototype.slice.call(arguments); | |
| const later = function() { | |
| timeout = undefined; | |
| if(!immediate) func.apply(context, args); | |
| }; | |
| const callNow = immediate && !timeout; | |
| clearTimeout(timeout); | |
| timeout = setTimeout(later, wait); | |
| if(callNow) func.apply(context, args); | |
| }; | |
| }; | |
| debounce.$defaultDelay = 500 /*arbitrary*/; | |
| SF.ForceResizeKludge = (function(){ | |
| /* Workaround for Safari mayhem regarding use of vh CSS | |
| units.... We cannot use vh units to set the main view | |
| size because Safari chokes on that, so we calculate | |
| that height here. Larger than ~95% is too big for | |
| Firefox on Android, causing the input area to move | |
| off-screen. */ | |
| const eVisibles = EAll('.app-view'); | |
| const elemsToCount = [ | |
| /* Elements which we need to always count in the | |
| visible body size. */ | |
| E('body > header'), | |
| E('body > footer'), | |
| E('body > fieldset.options') | |
| ]; | |
| const resized = function f(){ | |
| if(f.$disabled) return; | |
| const wh = window.innerHeight; | |
| var ht; | |
| var extra = 0; | |
| elemsToCount.forEach((e)=>e ? extra += effectiveHeight(e) : false); | |
| ht = wh - extra; | |
| eVisibles.forEach(function(e){ | |
| e.style.height = | |
| e.style.maxHeight = [ | |
| "calc(", (ht>=100 ? ht : 100), "px", | |
| " - 2em"/*fudge value*/,")" | |
| /* ^^^^ hypothetically not needed, but both | |
| Chrome/FF on Linux will force scrollbars on the | |
| body if this value is too small. */ | |
| ].join(''); | |
| }); | |
| }; | |
| resized.$disabled = true/*gets deleted when setup is finished*/; | |
| window.addEventListener('resize', debounce(resized, 250), false); | |
| return resized; | |
| })(); | |
| /** | |
| Performs all app initialization which must wait until after the | |
| worker module is loaded. This function removes itself when it's | |
| called. | |
| */ | |
| self.onSFLoaded = function(){ | |
| delete this.onSFLoaded; | |
| // Unhide all elements which start out hidden | |
| EAll('.initially-hidden').forEach((e)=>e.classList.remove('initially-hidden')); | |
| SF.e.main = EAll('.app-view:not(.hidden)')[0] | |
| /** The main view widget. Initially the first non-hidden | |
| .app-view element. */; | |
| if( (new URL(self.location.href).searchParams).has('about') ){ | |
| SF.toggleAbout() /* for use while editing the About page */; | |
| } | |
| E('#btn-reset').addEventListener('click',()=>SF.resetDb()); | |
| EAll('#btn-about, #btn-about-close').forEach((e)=>{ | |
| e.addEventListener('click',()=>SF.toggleAbout()) | |
| }); | |
| const taInput = E('#input'); | |
| const btnClearIn = E('#btn-clear'); | |
| const selectExamples = E('#select-examples'); | |
| btnClearIn.addEventListener('click',function(){ | |
| taInput.value = ''; | |
| selectExamples.selectedIndex = 0; | |
| },false); | |
| // Ctrl-enter and shift-enter both run the current SQL. | |
| taInput.addEventListener('keydown',function(ev){ | |
| if((ev.ctrlKey || ev.shiftKey) && 13 === ev.keyCode){ | |
| ev.preventDefault(); | |
| ev.stopPropagation(); | |
| btnShellExec.click(); | |
| } | |
| }, false); | |
| const taOutput = E('#output'); | |
| const btnClearOut = E('#btn-clear-output'); | |
| btnClearOut.addEventListener('click',function(){ | |
| taOutput.value = ''; | |
| if(SF.jqTerm) SF.jqTerm.clear(); | |
| },false); | |
| const btnShellExec = E('#btn-shell-exec'); | |
| btnShellExec.addEventListener('click',function(ev){ | |
| let sql; | |
| ev.preventDefault(); | |
| if(taInput.selectionStart<taInput.selectionEnd){ | |
| sql = taInput.value.substring(taInput.selectionStart,taInput.selectionEnd).trim(); | |
| }else{ | |
| sql = taInput.value.trim(); | |
| } | |
| if(sql) SF.dbExec(sql); | |
| },false); | |
| const btnInterrupt = E("#btn-interrupt"); | |
| //btnInterrupt.classList.add('hidden'); | |
| /** To be called immediately before work is sent to the | |
| worker. Updates some UI elements. The 'working'/'end' | |
| event will apply the inverse, undoing the bits this | |
| function does. This impl is not in the 'working'/'start' | |
| event handler because that event is given to us | |
| asynchronously _after_ we need to have performed this | |
| work. | |
| */ | |
| const preStartWork = function f(){ | |
| if(!f._){ | |
| const title = E('title'); | |
| f._ = { | |
| btnLabel: btnShellExec.innerText, | |
| pageTitle: title, | |
| pageTitleOrig: title.innerText | |
| }; | |
| } | |
| f._.pageTitle.innerText = "[working...] "+f._.pageTitleOrig; | |
| btnShellExec.setAttribute('disabled','disabled'); | |
| btnInterrupt.removeAttribute('disabled','disabled'); | |
| }; | |
| /* Sends the given text to the db module to evaluate as if it | |
| had been entered in the sqlite3 CLI shell. If it's null or | |
| empty, this is a no-op. */ | |
| SF.dbExec = function f(sql){ | |
| if(null!==sql && this.config.autoClearOutput){ | |
| this.echo._clearPending = true; | |
| } | |
| preStartWork(); | |
| this.wMsg('shellExec',sql); | |
| }; | |
| SF.addMsgHandler('working',function f(ev){ | |
| switch(ev.data){ | |
| case 'start': /* See notes in preStartWork(). */; return; | |
| case 'end': | |
| preStartWork._.pageTitle.innerText = preStartWork._.pageTitleOrig; | |
| btnShellExec.innerText = preStartWork._.btnLabel; | |
| btnShellExec.removeAttribute('disabled'); | |
| btnInterrupt.setAttribute('disabled','disabled'); | |
| return; | |
| } | |
| console.warn("Unhandled 'working' event:",ev.data); | |
| }); | |
| /* For each checkbox with data-csstgt, set up a handler which | |
| toggles the given CSS class on the element matching | |
| E(data-csstgt). */ | |
| EAll('input[type=checkbox][data-csstgt]') | |
| .forEach(function(e){ | |
| const tgt = E(e.dataset.csstgt); | |
| const cssClass = e.dataset.cssclass || 'error'; | |
| e.checked = tgt.classList.contains(cssClass); | |
| e.addEventListener('change', function(){ | |
| tgt.classList[ | |
| this.checked ? 'add' : 'remove' | |
| ](cssClass) | |
| }, false); | |
| }); | |
| /* For each checkbox with data-config=X, set up a binding to | |
| SF.config[X]. These must be set up AFTER data-csstgt | |
| checkboxes so that those two states can be synced properly. */ | |
| EAll('input[type=checkbox][data-config]') | |
| .forEach(function(e){ | |
| const confVal = !!SF.config[e.dataset.config]; | |
| if(e.checked !== confVal){ | |
| /* Ensure that data-csstgt mappings (if any) get | |
| synced properly. */ | |
| e.checked = confVal; | |
| e.dispatchEvent(new Event('change')); | |
| } | |
| e.addEventListener('change', function(){ | |
| SF.config[this.dataset.config] = this.checked; | |
| SF.storeConfig(); | |
| }, false); | |
| }); | |
| /* For each button with data-cmd=X, map a click handler which | |
| calls SF.dbExec(X). */ | |
| const cmdClick = function(){SF.dbExec(this.dataset.cmd);}; | |
| EAll('button[data-cmd]').forEach( | |
| e => e.addEventListener('click', cmdClick, false) | |
| ); | |
| btnInterrupt.addEventListener('click',function(){ | |
| SF.wMsg('interrupt'); | |
| }); | |
| /** Initiate a download of the db. */ | |
| const btnExport = E('#btn-export'); | |
| const eLoadDb = E('#load-db'); | |
| const btnLoadDb = E('#btn-load-db'); | |
| btnLoadDb.addEventListener('click', ()=>eLoadDb.click()); | |
| /** | |
| Enables (if passed true) or disables all UI elements which | |
| "might," if timed "just right," interfere with an | |
| in-progress db import/export/exec operation. | |
| */ | |
| const enableMutatingElements = function f(enable){ | |
| if(!f._elems){ | |
| f._elems = [ | |
| /* UI elements to disable while import/export are | |
| running. Normally the export is fast enough | |
| that this won't matter, but we really don't | |
| want to be reading (from outside of sqlite) the | |
| db when the user taps btnShellExec. */ | |
| btnShellExec, btnExport, eLoadDb | |
| ]; | |
| } | |
| f._elems.forEach( enable | |
| ? (e)=>e.removeAttribute('disabled') | |
| : (e)=>e.setAttribute('disabled','disabled') ); | |
| }; | |
| btnExport.addEventListener('click',function(){ | |
| enableMutatingElements(false); | |
| SF.wMsg('db-export'); | |
| }); | |
| SF.addMsgHandler('db-export', function(ev){ | |
| enableMutatingElements(true); | |
| ev = ev.data; | |
| if(ev.error){ | |
| SF.echo("Export failed:",ev.error); | |
| return; | |
| } | |
| const blob = new Blob([ev.buffer], | |
| {type:"application/x-sqlite3"}); | |
| const a = document.createElement('a'); | |
| document.body.appendChild(a); | |
| a.href = window.URL.createObjectURL(blob); | |
| a.download = ev.filename; | |
| a.addEventListener('click',function(){ | |
| setTimeout(function(){ | |
| SF.echo("Exported (possibly auto-downloaded):",ev.filename); | |
| window.URL.revokeObjectURL(a.href); | |
| a.remove(); | |
| },500); | |
| }); | |
| a.click(); | |
| }); | |
| /** | |
| Handle load/import of an external db file. | |
| */ | |
| eLoadDb.addEventListener('change',function(){ | |
| const f = this.files[0]; | |
| const r = new FileReader(); | |
| const status = {loaded: 0, total: 0}; | |
| enableMutatingElements(false); | |
| r.addEventListener('loadstart', function(){ | |
| SF.echo("Loading",f.name,"..."); | |
| }); | |
| r.addEventListener('progress', function(ev){ | |
| SF.echo("Loading progress:",ev.loaded,"of",ev.total,"bytes."); | |
| }); | |
| const that = this; | |
| r.addEventListener('load', function(){ | |
| enableMutatingElements(true); | |
| SF.echo("Loaded",f.name+". Opening db..."); | |
| SF.wMsg('open',{ | |
| filename: f.name, | |
| buffer: this.result | |
| }, [this.result]); | |
| }); | |
| r.addEventListener('error',function(){ | |
| enableMutatingElements(true); | |
| SF.echo("Loading",f.name,"failed for unknown reasons."); | |
| }); | |
| r.addEventListener('abort',function(){ | |
| enableMutatingElements(true); | |
| SF.echo("Cancelled loading of",f.name+"."); | |
| }); | |
| r.readAsArrayBuffer(f); | |
| }); | |
| EAll('fieldset.collapsible').forEach(function(fs){ | |
| const btnToggle = E(fs,'legend > .fieldset-toggle'), | |
| content = EAll(fs,':scope > div'); | |
| btnToggle.addEventListener('click', function(){ | |
| fs.classList.toggle('collapsed'); | |
| content.forEach((d)=>d.classList.toggle('hidden')); | |
| }, false); | |
| }); | |
| /** Set up a selection list of examples */ | |
| (function(){ | |
| const xElem = E('#select-examples'); | |
| const examples = [ | |
| {name: "Help", sql: [ | |
| "-- ================================================\n", | |
| "-- Use ctrl-enter or shift-enter to execute sqlite3\n", | |
| "-- shell commands and SQL.\n", | |
| "-- If a subset of the text is currently selected,\n", | |
| "-- only that part is executed.\n", | |
| "-- ================================================\n", | |
| ".help\n" | |
| ]}, | |
| //{name: "Timer on", sql: ".timer on"}, | |
| // ^^^ re-enable if emscripten re-enables getrusage() | |
| {name: "Box Mode", sql: ".mode box"}, | |
| {name: "Setup table T", sql:[ | |
| ".nullvalue NULL\n", | |
| "CREATE TABLE t(a,b);\n", | |
| "INSERT INTO t(a,b) VALUES('abc',123),('def',456),(NULL,789),('ghi',012);\n", | |
| "SELECT * FROM t;\n" | |
| ]}, | |
| {name: "sqlite_schema", sql: "select * from sqlite_schema"}, | |
| {name: "Mandelbrot", sql:[ | |
| "WITH RECURSIVE", | |
| " xaxis(x) AS (VALUES(-2.0) UNION ALL SELECT x+0.05 FROM xaxis WHERE x<1.2),\n", | |
| " yaxis(y) AS (VALUES(-1.0) UNION ALL SELECT y+0.1 FROM yaxis WHERE y<1.0),\n", | |
| " m(iter, cx, cy, x, y) AS (\n", | |
| " SELECT 0, x, y, 0.0, 0.0 FROM xaxis, yaxis\n", | |
| " UNION ALL\n", | |
| " SELECT iter+1, cx, cy, x*x-y*y + cx, 2.0*x*y + cy FROM m \n", | |
| " WHERE (x*x + y*y) < 4.0 AND iter<28\n", | |
| " ),\n", | |
| " m2(iter, cx, cy) AS (\n", | |
| " SELECT max(iter), cx, cy FROM m GROUP BY cx, cy\n", | |
| " ),\n", | |
| " a(t) AS (\n", | |
| " SELECT group_concat( substr(' .+*#', 1+min(iter/7,4), 1), '') \n", | |
| " FROM m2 GROUP BY cy\n", | |
| " )\n", | |
| "SELECT group_concat(rtrim(t),x'0a') as Mandelbrot FROM a;\n", | |
| ]}, | |
| {name: "JSON pretty-print", | |
| sql: "select json_pretty(json_object('ex',json('[52,3.14159]')))" | |
| }, | |
| {name: "JSON pretty-print (with tabs)", | |
| sql: "select json_pretty(json_object('ex',json('[52,3.14159]')),char(0x09))" | |
| } | |
| ]; | |
| const newOpt = function(lbl,val){ | |
| const o = document.createElement('option'); | |
| if(Array.isArray(val)) val = val.join(''); | |
| o.value = val; | |
| if(!val) o.setAttribute('disabled',true); | |
| o.appendChild(document.createTextNode(lbl)); | |
| xElem.appendChild(o); | |
| }; | |
| newOpt("Examples (replaces input!)"); | |
| examples.forEach((o)=>newOpt(o.name, o.sql)); | |
| //xElem.setAttribute('disabled',true); | |
| xElem.selectedIndex = 0; | |
| xElem.addEventListener('change', function(){ | |
| taInput.value = '-- ' + | |
| this.selectedOptions[0].innerText + | |
| '\n' + this.value; | |
| SF.dbExec(this.value); | |
| }); | |
| })()/* example queries */; | |
| //SF.echo(null/*clear any output generated by the init process*/); | |
| if(window.jQuery && window.jQuery.terminal && SF.e.terminal){ | |
| /* Set up the terminal-style view... */ | |
| const jqeTerm = window.jQuery(SF.e.terminal).empty(); | |
| SF.jqTerm = jqeTerm.terminal(SF.dbExec.bind(SF),{ | |
| prompt: 'sqlite> ', | |
| greetings: false /* note that the docs incorrectly call this 'greeting' */ | |
| }); | |
| EAll('.unhide-if-terminal-available').forEach(e=>{ | |
| e.classList.remove('hidden'); | |
| }); | |
| EAll('.remove-if-terminal-available').forEach(e=>{ | |
| e.parentElement.removeChild(e); | |
| }); | |
| /* Set up a button to toggle the views... */ | |
| const ePlaceholder = E('#terminal-button-placeholder'); | |
| ePlaceholder.classList.add('labeled-input'); | |
| ePlaceholder.classList.remove('hidden'); | |
| const btnToggleView = document.createElement('button'); | |
| btnToggleView.innerText = "Toggle view"; | |
| ePlaceholder.appendChild( btnToggleView ); | |
| btnToggleView.addEventListener('click',function f(){ | |
| const terminalOn = document.body.classList.toggle('terminal-mode'); | |
| SF.setMainView( terminalOn ? SF.e.terminal : SF.e.split ); | |
| }, false); | |
| btnToggleView.click()/*default to terminal view*/; | |
| } | |
| const urlParams = new URL(self.location.href).searchParams; | |
| SF.dbExec(urlParams.get('sql') || null); | |
| delete SF.ForceResizeKludge.$disabled; | |
| SF.ForceResizeKludge(); | |
| }/*onSFLoaded()*/; | |
| })(); | |