@lvce-editor/server 0.0.2

package/static/1914fad/packages/renderer-worker/src/parts/Ajax/Ajax.ipc.js

@@ -0,0 +1,8 @@
+import * as Command from '../Command/Command.js'
+import * as Ajax from './Ajax.js'
+
+// TODO only use Ajax module via ipc -> that way is is always lazyloaded
+export const __initialize__ = () => {
+  Command.register(270, Ajax.getJson)
+  Command.register(271, Ajax.getText)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Ajax/Ajax.js

@@ -0,0 +1,77 @@
+import ky, { HTTPError } from '../../../../../static/js/ky.js'
+
+export const state = {
+  async getJson(url, options) {
+    // cannot use ky(url).json() because it sets "accept: application/json"
+    // which doesn't work with preload, see
+    // https://stackoverflow.com/questions/41655955/why-are-preload-link-not-working-for-json-requests#answer-48645748
+    const response = await ky(url, options)
+    return response.json()
+  },
+  async getText(url, options) {
+    return ky(url, options).text()
+  },
+}
+
+/**
+ * @throws
+ */
+export const getJson = async (url, options = {}) => {
+  try {
+    const result = await state.getJson(url, options)
+    return result
+  } catch (error) {
+    if (
+      error &&
+      error instanceof TypeError &&
+      error.message === 'Failed to fetch'
+    ) {
+      throw new Error(
+        `Failed to request json from "${url}". Make sure that the server has CORS enabled`,
+        {
+          cause: error,
+        }
+      )
+    }
+    if (error && error instanceof HTTPError) {
+      let json
+      try {
+        json = await error.response.json()
+      } catch {
+        throw error
+      }
+      if (json && json.message) {
+        throw new Error(`Failed to request json from "${url}": ${json.message}`)
+      }
+    }
+    error.message = `Failed to request json from "${url}": ${error.message}`
+    throw error
+  }
+}
+
+export const getJsonLocal = (url) => {
+  return getJson(url, {
+    mode: 'no-cors',
+  })
+}
+
+export const getText = async (url, options = {}) => {
+  try {
+    const result = await state.getText(url, options)
+    return result
+  } catch (error) {
+    if (
+      error &&
+      error instanceof TypeError &&
+      error.message === 'Failed to fetch'
+    ) {
+      throw new Error(
+        `Failed to request text from "${url}". Make sure that the server has CORS enabled`,
+        {
+          cause: error,
+        }
+      )
+    }
+    throw new Error(`Failed to request text from "${url}"`, { cause: error })
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/Arrays/Arrays.js

@@ -0,0 +1,25 @@
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+
+export const insertInto = (array, start, newItems) => {
+  const originalLength = array.length
+  const newItemsLength = newItems.length
+  array.length = originalLength + newItemsLength
+  // Move the items after the start index, start from the end so that we don't overwrite any value.
+  for (let i = originalLength - 1; i >= start; i--) {
+    array[i + newItemsLength] = array[i]
+  }
+
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i]
+  }
+}
+
+/**
+ * Alternative to the native Array.splice method, it
+ * can only support limited number of items due to the maximum call stack size limit.
+ */
+export const splice = (array, start, deleteCount, newItems) => {
+  const result = array.splice(start, deleteCount)
+  insertInto(array, start, newItems)
+  return result
+}

package/static/1914fad/packages/renderer-worker/src/parts/Assert/Assert.js

@@ -0,0 +1,76 @@
+// TODO treeshake out this whole module in production
+
+const getType = (value) => {
+  switch (typeof value) {
+    case 'number':
+      return 'number'
+    case 'function':
+      return 'function'
+    case 'string':
+      return 'string'
+    case 'object':
+      if (value === null) {
+        return 'null'
+      }
+      if (Array.isArray(value)) {
+        return 'array'
+      }
+      return 'object'
+    case 'boolean':
+      return 'boolean'
+    default:
+      return 'unknown'
+  }
+}
+
+export const object = (value) => {
+  const type = getType(value)
+  if (type !== 'object') {
+    throw new Error('expected value to be of type object')
+  }
+}
+
+export const number = (value) => {
+  const type = getType(value)
+  if (type !== 'number') {
+    throw new Error('expected value to be of type number')
+  }
+  if (isNaN(value)) {
+    throw new Error('value is NaN')
+  }
+}
+
+export const array = (value) => {
+  const type = getType(value)
+  if (type !== 'array') {
+    throw new Error('expected value to be of type array')
+  }
+}
+
+export const string = (value) => {
+  const type = getType(value)
+  if (type !== 'string') {
+    throw new Error('expected value to be of type string')
+  }
+}
+
+export const null_ = (value) => {
+  const type = getType(value)
+  if (type !== 'null') {
+    throw new Error('expected value to be of type null')
+  }
+}
+
+export const boolean = (value) => {
+  const type = getType(value)
+  if (type !== 'boolean') {
+    throw new Error('expected value to be of type boolean')
+  }
+}
+
+export const fn = (value) => {
+  const type = getType(value)
+  if (type !== 'function') {
+    throw new Error('expected value to be of type function')
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/Audio/Audio.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as Audio from './Audio.js'
+
+export const __initialize__ = () => {
+  Command.register(4444, Audio.playBell)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Audio/Audio.js

@@ -0,0 +1,6 @@
+import * as RendererProcess from '../RendererProcess/RendererProcess.js'
+
+export const playBell = async () => {
+  const src = '/sounds/bell.oga'
+  await RendererProcess.invoke(/* Audio.play */ 3211, /* src */ src)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Base64/Base64.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as Base64 from './Base64.js'
+
+export const __initialize__ = () => {
+  Command.register(7890, Base64.decode)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Base64/Base64.js

@@ -0,0 +1,6 @@
+import * as JsBase64 from '../../../../../static/js/js-base64.js'
+
+export const decode = (encoded) => {
+  const decoded = JsBase64.decode(encoded)
+  return decoded
+}

package/static/1914fad/packages/renderer-worker/src/parts/Blob/Blob.ipc.js

@@ -0,0 +1,6 @@
+import * as Command from '../Command/Command.js'
+import * as Blob from './Blob.js'
+
+export const __initialize__ = () => {
+  Command.register(4356, Blob.base64StringToBlob)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Blob/Blob.js

@@ -0,0 +1,5 @@
+import * as BlobUtil from '../../../../../static/js/blob-util.js'
+
+export const base64StringToBlob = (base64String) => {
+  return BlobUtil.base64StringToBlob(base64String)
+}

package/static/1914fad/packages/renderer-worker/src/parts/CacheStorage/CacheStorage.ipc.js

@@ -0,0 +1,10 @@
+import * as Command from '../Command/Command.js'
+import * as CacheStorage from './CacheStorage.js'
+
+// TODO only use CacheStorage module via ipc -> that way is is always lazyloaded
+
+export const __initialize__ = () => {
+  Command.register(6800, CacheStorage.clearCache)
+  Command.register(6801, CacheStorage.setJson)
+  Command.register(6802, CacheStorage.getJson)
+}

package/static/1914fad/packages/renderer-worker/src/parts/CacheStorage/CacheStorage.js

@@ -0,0 +1,151 @@
+import * as Platform from '../Platform/Platform.js'
+
+const CACHE_NAME = 'lvce-runtime-1914fad'
+
+const shouldIgnoreError = (error) => {
+  // Firefox throws dom exception in private mode
+  return (
+    error &&
+    error instanceof DOMException &&
+    error.message === 'The operation is insecure.'
+  )
+}
+
+export const state = {
+  async getJson(key) {
+    try {
+      const response = await getResponse(key)
+      if (!response) {
+        return undefined
+      }
+      const json = await response.json()
+      return json
+    } catch (error) {
+      if (shouldIgnoreError(error)) {
+        return undefined
+      }
+      throw new Error(`Failed to get json from cache "${key}"`, {
+        cause: error,
+      })
+    }
+  },
+  async setJson(key, value) {
+    try {
+      await setResponse(key, JSON.stringify(value), 'application/json')
+    } catch (error) {
+      if (shouldIgnoreError(error)) {
+        return
+      }
+      throw new Error(`Failed to put json into cache "${key}"`, {
+        cause: error,
+      })
+    }
+  },
+}
+// TODO when caches is not defined -> should return undefined
+
+const getCache = async () => {
+  return await caches.open(CACHE_NAME)
+}
+
+const getResponse = async (key) => {
+  if (typeof caches === 'undefined') {
+    return undefined
+  }
+  if (Platform.getPlatform() === 'electron' && key.startsWith('/')) {
+    // workaround for custom protocol not working with cache storage
+    key = 'https://example.com' + key
+  }
+  const cache = await getCache()
+  const response = await cache.match(key)
+  return response
+}
+
+/**
+ * @throws
+ */
+export const getJson = (key) => {
+  return state.getJson(key)
+}
+
+/**
+ * @throws
+ */
+export const getTextFromCache = async (key) => {
+  try {
+    const response = await getResponse(key)
+    if (!response) {
+      return undefined
+    }
+    const text = await response.text()
+    return text
+  } catch (error) {
+    if (shouldIgnoreError(error)) {
+      return undefined
+    }
+    throw new Error(`Failed to get text from cache "${key}"`, {
+      cause: error,
+    })
+  }
+}
+
+const setResponse = async (key, value, contentType) => {
+  if (typeof caches === 'undefined') {
+    return
+  }
+  // TODO cache the cache (maybe)
+  if (
+    Platform.getPlatform() === 'electron' && // workaround for custom protocol not working with cache storage
+    key.startsWith('/')
+  ) {
+    key = 'https://example.com' + key
+  }
+  if (typeof value !== 'string') {
+    console.warn(`invalid value ${value}`)
+    return
+  }
+  const cache = await caches.open(CACHE_NAME)
+  await cache.put(
+    key,
+    new Response(value, {
+      headers: new Headers({
+        'Content-Type': contentType,
+        'Content-Length': `${value.length}`,
+      }),
+    })
+  )
+}
+
+export const setText = async (key, value, contentType) => {
+  try {
+    await setResponse(key, value, contentType)
+  } catch (error) {
+    if (shouldIgnoreError(error)) {
+      return undefined
+    }
+    throw new Error(`Failed to put item into cache "${key}"`, { cause: error })
+  }
+}
+
+export const setJson = async (key, value) => {
+  return state.setJson(key, value)
+}
+
+/**
+ * @throws
+ */
+export const clearCache = async () => {
+  if (typeof caches === 'undefined') {
+    return
+  }
+  try {
+    await caches.delete(CACHE_NAME)
+  } catch (error) {
+    if (shouldIgnoreError(error)) {
+      return
+    }
+    throw new Error('Failed to clear cache', {
+      cause: error,
+    })
+  }
+}

package/static/1914fad/packages/renderer-worker/src/parts/Callback/Callback.ipc.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as Callback from './Callback.js'
+
+export const __initialize__ = () => {
+  Command.register(67330, Callback.resolve)
+  Command.register(67331, Callback.reject)
+}

package/static/1914fad/packages/renderer-worker/src/parts/Callback/Callback.js

@@ -0,0 +1,50 @@
+export const state = {
+  callbacks: Object.create(null),
+  onceListeners: new Set(),
+  id: 2,
+}
+
+export const register = (resolve, reject) => {
+  state.callbacks[++state.id] = {
+    resolve,
+    reject,
+  }
+  return state.id
+}
+
+export const unregister = (id) => {
+  delete state.callbacks[id]
+}
+
+// TODO merge resolve and resolveEmpty
+export const resolve = (id, args) => {
+  if (!(id in state.callbacks)) {
+    console.log(args)
+    console.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].resolve(args)
+  delete state.callbacks[id]
+}
+
+export const resolveEmpty = (id) => {
+  if (!(id in state.callbacks)) {
+    console.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].resolve()
+}
+
+export const reject = (id, error) => {
+  if (!(id in state.callbacks)) {
+    console.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].reject(error)
+}
+
+export const isAllEmpty = () => {
+  return (
+    Object.keys(state.callbacks).length === 0 && state.onceListeners.size === 0
+  )
+}

package/static/1914fad/packages/renderer-worker/src/parts/ClipBoard/ClipBoard.ipc.js

@@ -0,0 +1,9 @@
+import * as Command from '../Command/Command.js'
+import * as ClipBoard from './ClipBoard.js'
+
+export const __initialize__ = () => {
+  Command.register(240, ClipBoard.readText)
+  Command.register(241, ClipBoard.writeText)
+  Command.register(243, ClipBoard.writeNativeFiles)
+  Command.register(244, ClipBoard.readNativeFiles)
+}

package/static/1914fad/packages/renderer-worker/src/parts/ClipBoard/ClipBoard.js

@@ -0,0 +1,55 @@
+import * as SharedProcess from '../SharedProcess/SharedProcess.js'
+
+export const state = {
+  async readText() {
+    let text
+    try {
+      // @ts-ignore
+      text = await navigator.clipboard.readText()
+    } catch (error) {
+      if (error.message === 'Read permission denied.') {
+        console.warn(
+          'Failed to paste text: The Browser disallowed reading from clipboard'
+        )
+      } else if (
+        error.message === 'navigator.clipboard.readText is not a function'
+      ) {
+        console.warn(
+          'Failed to paste text: The Clipboard Api is not available in Firefox'
+        )
+      } else {
+        console.warn(error)
+      }
+      return
+    }
+    return text
+  },
+  async writeText(path) {
+    try {
+      // @ts-ignore
+      await navigator.clipboard.writeText(path)
+    } catch (error) {
+      console.warn(error)
+    }
+  },
+}
+
+export const readText = () => {
+  return state.readText()
+}
+
+export const writeText = async (path) => {
+  await state.writeText(path)
+}
+
+export const writeNativeFiles = (type, files) => {
+  return SharedProcess.invoke(
+    /* command */ 'ClipBoard.writeFiles',
+    /* type */ type,
+    /* files */ files
+  )
+}
+
+export const readNativeFiles = () => {
+  return SharedProcess.invoke(/* command */ 'ClipBoard.readFiles')
+}

package/static/1914fad/packages/renderer-worker/src/parts/ColorPicker/ColorPicker.ipc.js

@@ -0,0 +1,8 @@
+import * as Command from '../Command/Command.js'
+import * as ColorPicker from './ColorPicker.js'
+
+export const __initialize__ = () => {
+  Command.register(1400, ColorPicker.open)
+  Command.register(1401, ColorPicker.close)
+
+}

package/static/1914fad/packages/renderer-worker/src/parts/ColorPicker/ColorPicker.js

@@ -0,0 +1,7 @@
+export const open = () => {
+  console.log('TODO open color picker')
+}
+
+export const close = () => {
+  console.log('TODO close color picker')
+}