From 48c26ad422f43175e7157955916b94f0c89508d1 Mon Sep 17 00:00:00 2001 From: zyxkad Date: Wed, 17 Jan 2024 11:13:43 -0700 Subject: [PATCH 1/2] bumb MCLA to v0.4.23 --- docs/.vitepress/analyzers/mcla.ts | 2 +- docs/public/scripts/mcla_worker.js | 369 +++++++++++++++-------------- 2 files changed, 197 insertions(+), 174 deletions(-) diff --git a/docs/.vitepress/analyzers/mcla.ts b/docs/.vitepress/analyzers/mcla.ts index 1dbc3945..b25c4e80 100644 --- a/docs/.vitepress/analyzers/mcla.ts +++ b/docs/.vitepress/analyzers/mcla.ts @@ -20,7 +20,7 @@ export { loadMCLA, } -const VERSION = "v0.4.22" +const VERSION = "v0.4.23" // const VERSION = "dev" const RESOURCES_BASE = "https://globemc.github.io/mcla" const GO_WASM_EXEC_URL = useCDN(`${RESOURCES_BASE}/${VERSION}/wasm_exec.js`) diff --git a/docs/public/scripts/mcla_worker.js b/docs/public/scripts/mcla_worker.js index fa8e0a7f..51d34a12 100644 --- a/docs/public/scripts/mcla_worker.js +++ b/docs/public/scripts/mcla_worker.js @@ -1,204 +1,227 @@ function openDB(name, version, onupgrade) { - return new Promise((resolve, reject) => { - const res = indexedDB.open(name, version) - res.onerror = (event) => { - reject(event) - } - res.onsuccess = (event) => { - resolve(event.target.result) - } - res.onupgradeneeded = (event) => { - onupgrade(event.target.result, event.oldVersion) - } - }) + return new Promise((resolve, reject) => { + const res = indexedDB.open(name, version) + res.onerror = (event) => { + reject(event) + } + res.onsuccess = (event) => { + resolve(event.target.result) + } + res.onupgradeneeded = (event) => { + onupgrade(event.target.result, event.oldVersion) + } + }) } function wrapDBReq(req) { - return new Promise((resolve, reject) => { - req.onerror = reject - req.onsuccess = resolve - }) + return new Promise((resolve, reject) => { + req.onerror = reject + req.onsuccess = resolve + }) } class DBStorage { - constructor(db) { - this._db = db - this._transaction = null - } + constructor(db) { + this._db = db + this._transaction = null + } - _newTrans() { - let transaction = this._db.transaction(["localStorage"], "readwrite") - transaction.oncomplete = () => {} - transaction.onabort = () => {} - transaction.onerror = (event) => { - console.error("Transaction on error:", event) - } - return transaction - } + _newTrans() { + let transaction = this._db.transaction(["localStorage"], "readwrite") + transaction.oncomplete = () => {} + transaction.onabort = () => {} + transaction.onerror = (event) => { + console.error("Transaction on error:", event) + } + return transaction + } - _getStore() { - return this._newTrans().objectStore("localStorage") - } + _getStore() { + return this._newTrans().objectStore("localStorage") + } - _getIndex() { - return this._getStore().index("k") - } + _getIndex() { + return this._getStore().index("k") + } - async getItem(key) { - const res = (await wrapDBReq(this._getIndex().get(key))).target.result - if (res) { - return res.v - } - return undefined - } + _openCursor() { + return this._getStore().openCursor() + } - async setItem(key, value) { - await wrapDBReq(this._getStore().put({ k: key, v: value })) - return - } + keys() { + return new Promise((resolve, reject) => { + const keys = [] + const request = this._openCursor() + request.onerror = reject + request.onsuccess = function(event) { + const cursor = event.target.result + if (cursor) { + const key = cursor.primaryKey + console.debug(key, cursor.value) + keys.push(key) + cursor.continue() + } else { + resolve(keys) + } + }; + }) + } - async removeItem(key) { - await wrapDBReq(this._getStore().delete(key)) - return - } + async getItem(key) { + const res = (await wrapDBReq(this._getIndex().get(key))).target.result + if (res) { + return res.v + } + return undefined + } + + async setItem(key, value) { + await wrapDBReq(this._getStore().put({ k: key, v: value })) + return + } + + async removeItem(key) { + await wrapDBReq(this._getStore().delete(key)) + return + } } async function setup(wasm_url) { - globalThis.localStorage = new DBStorage( - await openDB("mcla-worker-localStorage", 1, (db) => { - const localStore = db.createObjectStore("localStorage", { keyPath: "k" }) - localStore.createIndex("k", "k", { unique: true }) - }), - ) + globalThis.localStorage = new DBStorage( + await openDB("mcla-worker-localStorage", 1, (db) => { + const localStore = db.createObjectStore("localStorage", { keyPath: "k" }) + localStore.createIndex("k", "k", { unique: true }) + }), + ) - const go = new Go() - var res - if (WebAssembly.instantiateStreaming) { - res = await WebAssembly.instantiateStreaming( - fetch(wasm_url), - go.importObject, - ) - } else { - res = await fetch(wasm_url) - .then((res) => res.arrayBuffer()) - .then((bts) => WebAssembly.instantiate(bts, go.importObject)) - } - go.run(res.instance) - // the global variable MCLA cannot be defined instantly, so we have to poll it - function waitMCLA() { - if (this.MCLA) { - return - } - return new Promise((re) => setTimeout(re, 10)) // sleep 10ms - .then(waitMCLA) - } - await waitMCLA() + const go = new Go() + var res + if (WebAssembly.instantiateStreaming) { + res = await WebAssembly.instantiateStreaming( + fetch(wasm_url), + go.importObject, + ) + } else { + res = await fetch(wasm_url) + .then((res) => res.arrayBuffer()) + .then((bts) => WebAssembly.instantiate(bts, go.importObject)) + } + go.run(res.instance) + // the global variable MCLA cannot be defined instantly, so we have to poll it + function waitMCLA() { + if (this.MCLA) { + return + } + return new Promise((re) => setTimeout(re, 10)) // sleep 10ms + .then(waitMCLA) + } + await waitMCLA() } var objectsMap = [] var objIdPool = [] function putObj(obj) { - if (objIdPool.length) { - let i = objIdPool.pop() - objectsMap[i] = obj - return i - } - let i = objectsMap.length - objectsMap.push(obj) - return i + if (objIdPool.length) { + let i = objIdPool.pop() + objectsMap[i] = obj + return i + } + let i = objectsMap.length + objectsMap.push(obj) + return i } function releaseObj(i) { - objectsMap[i] = null - objIdPool.push(i) + objectsMap[i] = null + objIdPool.push(i) } function wrapRes(res) { - switch (typeof res) { - case "boolean": - case "number": - case "string": - case "undefined": - return res - case "function": - return { - __worker_function: true, - ptr: putObj(res), - } - case "object": - if (res === null) { - return res - } - if (res instanceof Array) { - let obj = new Array(res.length) - for (let i = 0; i < res.length; i++) { - obj[i] = wrapRes(res[i]) - } - return obj - } - let obj = new Object() - for (let k of Reflect.ownKeys(res)) { - let v = res[k] - if (typeof v === "function") { - obj[k] = { - __worker_function: true, - ptr: putObj((...args) => res[k](...args)), - } - } else { - obj[k] = wrapRes(v) - } - } - return obj - } - throw new Error("Unknown type of res: " + typeof res) + switch (typeof res) { + case "boolean": + case "number": + case "string": + case "undefined": + return res + case "function": + return { + __worker_function: true, + ptr: putObj(res), + } + case "object": + if (res === null) { + return res + } + if (res instanceof Array) { + let obj = new Array(res.length) + for (let i = 0; i < res.length; i++) { + obj[i] = wrapRes(res[i]) + } + return obj + } + let obj = new Object() + for (let k of Reflect.ownKeys(res)) { + let v = res[k] + if (typeof v === "function") { + obj[k] = { + __worker_function: true, + ptr: putObj((...args) => res[k](...args)), + } + } else { + obj[k] = wrapRes(v) + } + } + return obj + } + throw new Error("Unknown type of res: " + typeof res) } this.onmessage = async (event) => { - const { data } = event - try { - switch (data.type) { - case "setup": - await this.importScripts(data.wasm_exec /* @vite-ignore */) // set variable `this.Go` - await setup(data.wasm_url) - this.postMessage({ - _id: data._id, - version: MCLA.version, - }) - break - case "call": { - let fn = MCLA[data.name] - if (typeof fn !== "function") { - throw `MCLA.${data.name} is not a function` - } - let res = await fn(...data.args) - this.postMessage({ - _id: data._id, - res: wrapRes(res), - }) - break - } - case "callObj": { - let fn = objectsMap[data.ptr] - if (typeof fn !== "function") { - throw `Object [${data.ptr}] is not a function` - } - let res = await fn(...data.args) - this.postMessage({ - _id: data._id, - res: wrapRes(res), - }) - break - } - case "releaseObj": { - releaseObj(data.ptr) - break - } - } - } catch (err) { - if (typeof data._id !== "undefined") { - this.postMessage({ - _id: data._id, - _error: String(err), - }) - } - } + const { data } = event + try { + switch (data.type) { + case "setup": + await this.importScripts(data.wasm_exec /* @vite-ignore */) // set variable `this.Go` + await setup(data.wasm_url) + this.postMessage({ + _id: data._id, + version: MCLA.version, + }) + break + case "call": { + let fn = MCLA[data.name] + if (typeof fn !== "function") { + throw `MCLA.${data.name} is not a function` + } + let res = await fn(...data.args) + this.postMessage({ + _id: data._id, + res: wrapRes(res), + }) + break + } + case "callObj": { + let fn = objectsMap[data.ptr] + if (typeof fn !== "function") { + throw `Object [${data.ptr}] is not a function` + } + let res = await fn(...data.args) + this.postMessage({ + _id: data._id, + res: wrapRes(res), + }) + break + } + case "releaseObj": { + releaseObj(data.ptr) + break + } + } + } catch (err) { + if (typeof data._id !== "undefined") { + this.postMessage({ + _id: data._id, + _error: String(err), + }) + } + } } From e181b8baa8fa54c410e491f15518395bc66c2195 Mon Sep 17 00:00:00 2001 From: zyxkad Date: Wed, 17 Jan 2024 11:34:50 -0700 Subject: [PATCH 2/2] format use space --- docs/public/scripts/mcla_worker.js | 388 ++++++++++++++--------------- 1 file changed, 194 insertions(+), 194 deletions(-) diff --git a/docs/public/scripts/mcla_worker.js b/docs/public/scripts/mcla_worker.js index 51d34a12..1abd2a62 100644 --- a/docs/public/scripts/mcla_worker.js +++ b/docs/public/scripts/mcla_worker.js @@ -1,227 +1,227 @@ function openDB(name, version, onupgrade) { - return new Promise((resolve, reject) => { - const res = indexedDB.open(name, version) - res.onerror = (event) => { - reject(event) - } - res.onsuccess = (event) => { - resolve(event.target.result) - } - res.onupgradeneeded = (event) => { - onupgrade(event.target.result, event.oldVersion) - } - }) + return new Promise((resolve, reject) => { + const res = indexedDB.open(name, version) + res.onerror = (event) => { + reject(event) + } + res.onsuccess = (event) => { + resolve(event.target.result) + } + res.onupgradeneeded = (event) => { + onupgrade(event.target.result, event.oldVersion) + } + }) } function wrapDBReq(req) { - return new Promise((resolve, reject) => { - req.onerror = reject - req.onsuccess = resolve - }) + return new Promise((resolve, reject) => { + req.onerror = reject + req.onsuccess = resolve + }) } class DBStorage { - constructor(db) { - this._db = db - this._transaction = null - } + constructor(db) { + this._db = db + this._transaction = null + } - _newTrans() { - let transaction = this._db.transaction(["localStorage"], "readwrite") - transaction.oncomplete = () => {} - transaction.onabort = () => {} - transaction.onerror = (event) => { - console.error("Transaction on error:", event) - } - return transaction - } + _newTrans() { + let transaction = this._db.transaction(["localStorage"], "readwrite") + transaction.oncomplete = () => {} + transaction.onabort = () => {} + transaction.onerror = (event) => { + console.error("Transaction on error:", event) + } + return transaction + } - _getStore() { - return this._newTrans().objectStore("localStorage") - } + _getStore() { + return this._newTrans().objectStore("localStorage") + } - _getIndex() { - return this._getStore().index("k") - } + _getIndex() { + return this._getStore().index("k") + } - _openCursor() { - return this._getStore().openCursor() - } + _openCursor() { + return this._getStore().openCursor() + } - keys() { - return new Promise((resolve, reject) => { - const keys = [] - const request = this._openCursor() - request.onerror = reject - request.onsuccess = function(event) { - const cursor = event.target.result - if (cursor) { - const key = cursor.primaryKey - console.debug(key, cursor.value) - keys.push(key) - cursor.continue() - } else { - resolve(keys) - } - }; - }) - } + keys() { + return new Promise((resolve, reject) => { + const keys = [] + const request = this._openCursor() + request.onerror = reject + request.onsuccess = function(event) { + const cursor = event.target.result + if (cursor) { + const key = cursor.primaryKey + console.debug(key, cursor.value) + keys.push(key) + cursor.continue() + } else { + resolve(keys) + } + }; + }) + } - async getItem(key) { - const res = (await wrapDBReq(this._getIndex().get(key))).target.result - if (res) { - return res.v - } - return undefined - } + async getItem(key) { + const res = (await wrapDBReq(this._getIndex().get(key))).target.result + if (res) { + return res.v + } + return undefined + } - async setItem(key, value) { - await wrapDBReq(this._getStore().put({ k: key, v: value })) - return - } + async setItem(key, value) { + await wrapDBReq(this._getStore().put({ k: key, v: value })) + return + } - async removeItem(key) { - await wrapDBReq(this._getStore().delete(key)) - return - } + async removeItem(key) { + await wrapDBReq(this._getStore().delete(key)) + return + } } async function setup(wasm_url) { - globalThis.localStorage = new DBStorage( - await openDB("mcla-worker-localStorage", 1, (db) => { - const localStore = db.createObjectStore("localStorage", { keyPath: "k" }) - localStore.createIndex("k", "k", { unique: true }) - }), - ) + globalThis.localStorage = new DBStorage( + await openDB("mcla-worker-localStorage", 1, (db) => { + const localStore = db.createObjectStore("localStorage", { keyPath: "k" }) + localStore.createIndex("k", "k", { unique: true }) + }), + ) - const go = new Go() - var res - if (WebAssembly.instantiateStreaming) { - res = await WebAssembly.instantiateStreaming( - fetch(wasm_url), - go.importObject, - ) - } else { - res = await fetch(wasm_url) - .then((res) => res.arrayBuffer()) - .then((bts) => WebAssembly.instantiate(bts, go.importObject)) - } - go.run(res.instance) - // the global variable MCLA cannot be defined instantly, so we have to poll it - function waitMCLA() { - if (this.MCLA) { - return - } - return new Promise((re) => setTimeout(re, 10)) // sleep 10ms - .then(waitMCLA) - } - await waitMCLA() + const go = new Go() + var res + if (WebAssembly.instantiateStreaming) { + res = await WebAssembly.instantiateStreaming( + fetch(wasm_url), + go.importObject, + ) + } else { + res = await fetch(wasm_url) + .then((res) => res.arrayBuffer()) + .then((bts) => WebAssembly.instantiate(bts, go.importObject)) + } + go.run(res.instance) + // the global variable MCLA cannot be defined instantly, so we have to poll it + function waitMCLA() { + if (this.MCLA) { + return + } + return new Promise((re) => setTimeout(re, 10)) // sleep 10ms + .then(waitMCLA) + } + await waitMCLA() } var objectsMap = [] var objIdPool = [] function putObj(obj) { - if (objIdPool.length) { - let i = objIdPool.pop() - objectsMap[i] = obj - return i - } - let i = objectsMap.length - objectsMap.push(obj) - return i + if (objIdPool.length) { + let i = objIdPool.pop() + objectsMap[i] = obj + return i + } + let i = objectsMap.length + objectsMap.push(obj) + return i } function releaseObj(i) { - objectsMap[i] = null - objIdPool.push(i) + objectsMap[i] = null + objIdPool.push(i) } function wrapRes(res) { - switch (typeof res) { - case "boolean": - case "number": - case "string": - case "undefined": - return res - case "function": - return { - __worker_function: true, - ptr: putObj(res), - } - case "object": - if (res === null) { - return res - } - if (res instanceof Array) { - let obj = new Array(res.length) - for (let i = 0; i < res.length; i++) { - obj[i] = wrapRes(res[i]) - } - return obj - } - let obj = new Object() - for (let k of Reflect.ownKeys(res)) { - let v = res[k] - if (typeof v === "function") { - obj[k] = { - __worker_function: true, - ptr: putObj((...args) => res[k](...args)), - } - } else { - obj[k] = wrapRes(v) - } - } - return obj - } - throw new Error("Unknown type of res: " + typeof res) + switch (typeof res) { + case "boolean": + case "number": + case "string": + case "undefined": + return res + case "function": + return { + __worker_function: true, + ptr: putObj(res), + } + case "object": + if (res === null) { + return res + } + if (res instanceof Array) { + let obj = new Array(res.length) + for (let i = 0; i < res.length; i++) { + obj[i] = wrapRes(res[i]) + } + return obj + } + let obj = new Object() + for (let k of Reflect.ownKeys(res)) { + let v = res[k] + if (typeof v === "function") { + obj[k] = { + __worker_function: true, + ptr: putObj((...args) => res[k](...args)), + } + } else { + obj[k] = wrapRes(v) + } + } + return obj + } + throw new Error("Unknown type of res: " + typeof res) } this.onmessage = async (event) => { - const { data } = event - try { - switch (data.type) { - case "setup": - await this.importScripts(data.wasm_exec /* @vite-ignore */) // set variable `this.Go` - await setup(data.wasm_url) - this.postMessage({ - _id: data._id, - version: MCLA.version, - }) - break - case "call": { - let fn = MCLA[data.name] - if (typeof fn !== "function") { - throw `MCLA.${data.name} is not a function` - } - let res = await fn(...data.args) - this.postMessage({ - _id: data._id, - res: wrapRes(res), - }) - break - } - case "callObj": { - let fn = objectsMap[data.ptr] - if (typeof fn !== "function") { - throw `Object [${data.ptr}] is not a function` - } - let res = await fn(...data.args) - this.postMessage({ - _id: data._id, - res: wrapRes(res), - }) - break - } - case "releaseObj": { - releaseObj(data.ptr) - break - } - } - } catch (err) { - if (typeof data._id !== "undefined") { - this.postMessage({ - _id: data._id, - _error: String(err), - }) - } - } + const { data } = event + try { + switch (data.type) { + case "setup": + await this.importScripts(data.wasm_exec /* @vite-ignore */) // set variable `this.Go` + await setup(data.wasm_url) + this.postMessage({ + _id: data._id, + version: MCLA.version, + }) + break + case "call": { + let fn = MCLA[data.name] + if (typeof fn !== "function") { + throw `MCLA.${data.name} is not a function` + } + let res = await fn(...data.args) + this.postMessage({ + _id: data._id, + res: wrapRes(res), + }) + break + } + case "callObj": { + let fn = objectsMap[data.ptr] + if (typeof fn !== "function") { + throw `Object [${data.ptr}] is not a function` + } + let res = await fn(...data.args) + this.postMessage({ + _id: data._id, + res: wrapRes(res), + }) + break + } + case "releaseObj": { + releaseObj(data.ptr) + break + } + } + } catch (err) { + if (typeof data._id !== "undefined") { + this.postMessage({ + _id: data._id, + _error: String(err), + }) + } + } }