@lvce-editor/shared-process 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-present, Le Vivilet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# shared process
+
+The `shared-process` is a NodeJS process that is used for sending files to the Browser via WebSockets.
+
+- `shared-process` is created by the `web` process
+- `shared-process` launches the `extension-host`
+- `shared-process` communicates with `renderer-worker` via WebSockets
+
+<!--
+For example, this is how readFile is implemented in renderer-worker:
+
+```js
+export const readFile = (path) => {
+  return SharedProcess.invoke(/* readFile */ 101, /* path */ path)
+}
+```
+
+This will be send to the shared-process
+
+```json
+{
+  "jsonrpc": "2.0",
+  "method": 101,
+  "params": ["/tmp/index.css"],
+  "id": 19
+}
+```
+
+And the shared-process will send back
+
+````json
+{
+  "jsonrpc": "2.0",
+  "result": "h1 {\n font-size: 20px;\n}\n",
+  "id": 19
+}
+``` -->
+
+```
+
+```

package/bin/sharedProcess.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../src/sharedProcessMain.js'

package/index.js

@@ -0,0 +1,6 @@
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export const sharedProcessPath = join(__dirname, 'src', 'sharedProcessMain.js')

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@lvce-editor/shared-process",
+  "version": "0.0.2",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "node --unhandled-rejections=warn --experimental-vm-modules ../../node_modules/jest/bin/jest.js --detectOpenHandles --forceExit",
+    "test:watch": "node --unhandled-rejections=warn --experimental-vm-modules ../../node_modules/jest/bin/jest.js --watch"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chokidar": "^3.5.3",
+    "clipboardy": "^3.0.0",
+    "debug": "^4.3.4",
+    "execa": "^6.1.0",
+    "exit-hook": "^3.0.0",
+    "fs-extra": "^10.1.0",
+    "got": "^12.1.0",
+    "is-object": "^1.0.2",
+    "json-parse-even-better-errors": "^2.3.1",
+    "jsonc-parser": "^3.0.0",
+    "lines-and-columns": "^2.0.3",
+    "open": "^8.4.0",
+    "p-queue": "^7.2.0",
+    "parse-json": "^6.0.2",
+    "tail": "^2.2.4",
+    "tar-fs": "^2.1.1",
+    "trash": "^8.1.0",
+    "verror": "^1.10.1",
+    "ws": "^8.8.0",
+    "xdg-basedir": "^5.1.0",
+    "@lvce-editor/pty-host": "0.0.2",
+    "@lvce-editor/extension-host": "0.0.2"
+  },
+  "optionalDependencies": {
+    "electron-clipboard-ex": "^1.3.3",
+    "keytar": "^7.9.0",
+    "vscode-ripgrep-with-github-api-error-fix": "^2.4.1"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/fs-extra": "^9.0.13",
+    "@types/is-ci": "^3.0.0",
+    "@types/is-object": "^1.0.2",
+    "@types/tail": "^2.2.1",
+    "@types/tar-fs": "^2.0.1",
+    "@types/verror": "^1.10.5",
+    "@types/ws": "^8.5.3",
+    "get-port": "^6.1.2",
+    "is-ci": "^3.0.1"
+  },
+  "xo": {
+    "rules": {
+      "unicorn/filename-case": "off",
+      "indent": "off",
+      "semi": "off",
+      "no-unused-vars": "off",
+      "unicorn/numeric-separators-style": "off",
+      "no-extra-semi": "off",
+      "arrow-body-style": "off",
+      "padded-blocks": "off",
+      "capitalized-comments": "off",
+      "padding-line-between-statements": "off",
+      "arrow-parens": "off",
+      "no-warning-comments": "off",
+      "array-bracket-spacing": "off",
+      "comma-spacing": "off",
+      "unicorn/no-array-callback-reference": "off",
+      "comma-dangle": "off",
+      "operator-linebreak": "off",
+      "no-case-declarations": "off",
+      "no-undef": "off",
+      "object-curly-spacing": "off",
+      "object-shorthand": "off",
+      "complexity": "off",
+      "no-labels": "off",
+      "no-multi-assign": "off",
+      "max-params": "off",
+      "no-bitwise": "off",
+      "unicorn/prefer-math-trunc": "off",
+      "no-await-in-loop": "off",
+      "unicorn/prefer-add-event-listener": "off",
+      "no-unused-expressions": "off",
+      "node/prefer-global/process": "off",
+      "unicorn/prevent-abbreviations": "off",
+      "unicorn/no-process-exit": "off",
+      "quotes": "off"
+    },
+    "ignores": [
+      "distmin"
+    ]
+  }
+}

package/src/parts/Assert/Assert.js

@@ -0,0 +1,57 @@
+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')
+  }
+}
+
+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 boolean = (value) => {
+  const type = getType(value)
+  if (type !== 'boolean') {
+    throw new Error('expected value to be of type boolean')
+  }
+}

package/src/parts/Callback/Callback.js

@@ -0,0 +1,48 @@
+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.warn(`callback ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].resolve(args)
+}
+
+export const resolveEmpty = (id) => {
+  if (!(id in state.callbacks)) {
+    console.warn(`callback (resolved) ${id} may already be disposed`)
+    return
+  }
+  state.callbacks[id].resolve()
+}
+
+export const reject = (id, error) => {
+  if (!(id in state.callbacks)) {
+    console.warn(`callback (rejected) ${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/src/parts/ChildProcess/ChildProcess.js

@@ -0,0 +1,98 @@
+import * as NodeChildProcess from 'node:child_process'
+import { Worker } from 'node:worker_threads'
+import exitHook from 'exit-hook'
+import * as Debug from '../Debug/Debug.js'
+
+export const state = {
+  /** @type{ChildProcess[]} */
+  childProcesses: [],
+}
+
+const cleanUpAll = () => {
+  for (const childProcess of state.childProcesses) {
+    childProcess.kill()
+  }
+}
+
+const handleProcessExit = () => {
+  Debug.debug('exiting')
+  console.info('[shared process] exiting')
+  cleanUpAll()
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {NodeChildProcess.ForkOptions } options
+ * @returns
+ */
+export const fork = (path, options) => {
+  exitHook(handleProcessExit)
+  const childProcess = NodeChildProcess.fork(path, options)
+
+  // childProcess.on('error', (error) => {
+  //   onError(error)
+  // })
+
+  // childProcess.on('exit', (exitCode) => {
+  //   onExit(exitCode)
+  // })
+
+  // childProcess.once('message', (message) => {
+  //   if (message === 'ready') {
+  //     onReady()
+  //     childProcess.on('message', onMessage)
+  //     // TODO remove jsonrpc part from here
+  //     // childProcess.on('message', (message) => {
+  //     //   // @ts-ignore
+  //     //   if ('result' in message) {
+  //     //     // @ts-ignore
+  //     //     callbacks[message.id](message.result)
+  //     //     // @ts-ignore
+  //     //     delete callbacks[message.id]
+  //     //   } else {
+  //     //     onMessage(message)
+  //     //   }
+  //     // })
+  //   }
+  // })
+
+  state.childProcesses.push(childProcess)
+
+  return childProcess
+}
+
+export const disposeFork = (childProcess) => {
+  childProcess.kill()
+}
+
+export const createWorker = (path, { onError, onExit, onMessage }) => {
+  const worker = new Worker(path, {
+    resourceLimits: {
+      maxOldGenerationSizeMb: 10,
+      maxYoungGenerationSizeMb: 10,
+    },
+  })
+
+  worker.on('error', (error) => {
+    onError(error)
+  })
+
+  worker.on('exit', (exitCode) => {
+    onExit(exitCode)
+  })
+
+  worker.on('message', (message) => {
+    onMessage(message)
+  })
+
+  return {
+    dispose() {
+      worker.terminate()
+    },
+    send(message) {
+      worker.postMessage(message)
+    },
+    async invoke(commandId, ...args) {},
+  }
+}

package/src/parts/ClipBoard/ClipBoard.ipc.js

@@ -0,0 +1,7 @@
+import * as Command from '../Command/Command.js'
+import * as ClipBoard from './ClipBoard.js'
+
+export const __initialize__ = () => {
+  Command.register('ClipBoard.readFiles', ClipBoard.readFiles)
+  Command.register('ClipBoard.writeFiles', ClipBoard.writeFiles)
+}

package/src/parts/ClipBoard/ClipBoard.js

@@ -0,0 +1,23 @@
+import * as Platform from '../Platform/Platform.js'
+
+const getClipboard = () => {
+  const desktop = Platform.getDesktop()
+  switch (desktop) {
+    case 'gnome':
+      return import('./ClipBoardGnome.js')
+    case 'windows':
+      return import('./ClipBoardWindows.js')
+    default:
+      return import('./ClipBoardNoop.js')
+  }
+}
+
+export const readFiles = async () => {
+  const clipboard = await getClipboard()
+  return clipboard.readFiles()
+}
+
+export const writeFiles = async (type, files) => {
+  const clipboard = await getClipboard()
+  await clipboard.writeFiles(type, files)
+}

package/src/parts/ClipBoard/ClipBoardGnome.js

@@ -0,0 +1,78 @@
+// see https://www.cyberciti.biz/faq/how-do-i-copy-a-file-to-the-clipboard-in-linux
+// see also http://manpages.ubuntu.com/manpages/bionic/man1/xclip.1.html
+// on gnome, get current selection targets with `xclip -selection clipboard -t TARGETS -o`
+
+import VError from 'verror'
+import * as Exec from '../Exec/Exec.js'
+
+const removePrefix = (file) => {
+  if (file.startsWith('file://')) {
+    return file.slice('file://'.length)
+  }
+  return file
+}
+
+const addPrefix = (file) => {
+  return `file://${file}`
+}
+
+export const readFiles = async () => {
+  let result
+  try {
+    result = await Exec.exec(
+      'xclip',
+      ['-selection', 'clipboard', '-o', '-t', 'x-special/gnome-copied-files'],
+      {}
+    )
+  } catch (error) {
+    if (
+      error &&
+      // @ts-ignore
+      error.stderr ===
+        'Error: target x-special/gnome-copied-files not available'
+    ) {
+      return
+    }
+    throw error
+  }
+  const [type, ...files] = result.stdout.split('\n')
+  const actualFiles = files.map(removePrefix)
+  return {
+    source: 'gnomeCopiedFiles',
+    type,
+    files: actualFiles,
+  }
+}
+
+export const writeFiles = async (type, files) => {
+  const filesWithPrefix = files.map(addPrefix)
+  const gnomeCopiedFilesContent = [type, ...filesWithPrefix].join('\n')
+  const uriListContent = filesWithPrefix.join('\n')
+  const plainContent = files.join('\n')
+  try {
+    await Exec.exec(
+      'xclip',
+      ['-i', '-selection', 'clipboard', '-t', 'x-special/gnome-copied-files'],
+      {
+        input: gnomeCopiedFilesContent,
+      }
+    )
+    await Exec.exec(
+      'xclip',
+      ['-i', '-selection', 'clipboard', '-t', 'text/uri-list'],
+      {
+        input: uriListContent,
+      }
+    )
+    await Exec.exec(
+      'xclip',
+      ['-i', '-selection', 'clipboard', '-t', 'text/plain'],
+      {
+        input: plainContent,
+      }
+    )
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, 'Failed to copy files to clipboard')
+  }
+}

package/src/parts/ClipBoard/ClipBoardNoop.js

@@ -0,0 +1,14 @@
+import * as Platform from '../Platform/Platform.js'
+
+export const readFiles = async () => {
+  return {
+    source: 'notSupported',
+    type: 'none',
+    files: [],
+  }
+}
+
+export const writeFiles = (type, files) => {
+  const desktop = Platform.getDesktop()
+  console.info(`writing files to clipboard is not yet supported on ${desktop}`)
+}

package/src/parts/ClipBoard/ClipBoardWindows.js

@@ -0,0 +1,22 @@
+import clipboardEx from 'electron-clipboard-ex'
+
+import VError from 'verror'
+
+export const readFiles = async () => {
+  const filePaths = clipboardEx.readFilePaths()
+  console.log(filePaths)
+  return {
+    source: 'electron-clipboard-ex',
+    type: 'copy', // TODO can't be sure on this
+    files: filePaths,
+  }
+}
+
+export const writeFiles = async (type, files) => {
+  try {
+    clipboardEx.writeFilePaths(files)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, 'Failed to copy files to clipboard')
+  }
+}