@lvce-editor/typescript-compile-process 0.0.0-dev

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-present, Lvce Editor
+
+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/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@lvce-editor/typescript-compile-process",
+  "version": "0.0.0-dev",
+  "main": "index.js",
+  "type": "module",
+  "keywords": [
+    "Lvce Editor"
+  ],
+  "author": "Lvce Editor",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lvce-editor/lvce-editor.git",
+    "directory": "packages/typescript-compile-process"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@lvce-editor/assert": "^1.2.0",
+    "@lvce-editor/ipc": "^8.2.0",
+    "@lvce-editor/json-rpc": "^1.3.0",
+    "@lvce-editor/pretty-error": "^1.5.0",
+    "@lvce-editor/verror": "^1.2.0"
+  }
+}

package/src/parts/Assert/Assert.js

@@ -0,0 +1 @@
+export * from '@lvce-editor/assert'

package/src/parts/Callback/Callback.js

@@ -0,0 +1 @@
+export { resolve } from '@lvce-editor/json-rpc'

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from '../CommandState/CommandState.js'
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command)
+  if (!fn) {
+    throw new Error(`Command not found ${command}`)
+  }
+  return fn(...args)
+}

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,7 @@
+import * as HandleElectronMessagePort from '../HandleElectronMessagePort/HandleElectronMessagePort.js'
+import * as TranspileTypeScript from '../TranspileTypeScript/TranspileTypeScript.js'
+
+export const commandMap = {
+  'TranspileTypeScript.transpileTypeScript': TranspileTypeScript.transpileTypeScript,
+  'HandleElectronMessagePort.handleElectronMessagePort': HandleElectronMessagePort.handleElectronMessagePort,
+}

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,17 @@
+export const state = {
+  commands: Object.create(null),
+}
+
+export const registerCommand = (key, fn) => {
+  state.commands[key] = fn
+}
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value)
+  }
+}
+
+export const getCommand = (key) => {
+  return state.commands[key]
+}

package/src/parts/GetTypeScriptPath/GetTypeScriptPath.js

@@ -0,0 +1,22 @@
+import { join } from 'node:path'
+import * as IsBuiltServer from '../IsBuiltServer/IsBuiltServer.js'
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
+import * as Platform from '../Platform/Platform.js'
+import { pathToFileURL } from 'node:url'
+
+export const getTypeScriptUri = () => {
+  if (!Platform.isProduction || IsBuiltServer.isBuiltServer) {
+    return 'typescript'
+  }
+  const typescriptPath = join(
+    PlatformPaths.getBuiltinExtensionsPath(),
+    'builtin.language-features-typescript',
+    'node',
+    'node_modules',
+    'typescript',
+    'lib',
+    'typescript.js',
+  )
+  const typescriptUri = pathToFileURL(typescriptPath).toString()
+  return typescriptUri
+}

package/src/parts/HandleElectronMessagePort/HandleElectronMessagePort.js

@@ -0,0 +1,15 @@
+import * as Assert from '../Assert/Assert.js'
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const handleElectronMessagePort = async (messagePort, ipcId) => {
+  Assert.object(messagePort)
+  // Assert.number(ipcId)
+  // TODO use handleIncomingIpc function
+  const ipc = await IpcChild.listen({
+    method: IpcChildType.ElectronMessagePort,
+    messagePort,
+  })
+  HandleIpc.handleIpc(ipc)
+}

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,5 @@
+import * as HandleMessage from '../HandleMessage/HandleMessage.js'
+
+export const handleIpc = (ipc) => {
+  ipc.addEventListener('message', HandleMessage.handleMessage)
+}

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,19 @@
+import * as Callback from '../Callback/Callback.js'
+import * as Command from '../Command/Command.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+const prepare = (error) => {
+  return error
+}
+
+const requiresSocket = (method) => {
+  return false
+}
+
+const logError = (error, prettyError) => {
+  console.error(error)
+}
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(event.target, event.data, Command.execute, Callback.resolve, prepare, logError, requiresSocket)
+}

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,15 @@
+import * as IpcChildModule from '../IpcChildModule/IpcChildModule.js'
+
+export const listen = async ({ method, ...params }) => {
+  const module = await IpcChildModule.getModule(method)
+  // @ts-ignore
+  const rawIpc = await module.listen(params)
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc)
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,25 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from '@lvce-editor/ipc'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess
+    case IpcChildType.NodeWorker:
+      return IpcChildWithNodeWorker
+    case IpcChildType.ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess
+    case IpcChildType.ElectronMessagePort:
+      return IpcChildWithElectronMessagePort
+    case IpcChildType.WebSocket:
+      return IpcChildWithWebSocket
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,20 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3
+export const ElectronMessagePort = 4
+export const NodeMessagePort = 5
+export const WebSocket = 6
+
+export const Auto = () => {
+  const { argv } = process
+  if (argv.includes('--ipc-type=node-worker')) {
+    return NodeWorker
+  }
+  if (argv.includes('--ipc-type=node-forked-process')) {
+    return NodeForkedProcess
+  }
+  if (argv.includes('--ipc-type=electron-utility-process')) {
+    return ElectronUtilityProcess
+  }
+  throw new Error(`[shared-process] unknown ipc type`)
+}

package/src/parts/IsBuiltServer/IsBuiltServer.js

@@ -0,0 +1 @@
+export const isBuiltServer = false

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1 @@
+export * from '@lvce-editor/json-rpc'

package/src/parts/Listen/Listen.js

@@ -0,0 +1,8 @@
+import * as HandleIpc from '../HandleIpc/HandleIpc.js'
+import * as IpcChild from '../IpcChild/IpcChild.js'
+import * as IpcChildType from '../IpcChildType/IpcChildType.js'
+
+export const listen = async () => {
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() })
+  HandleIpc.handleIpc(ipc)
+}

package/src/parts/LoadTypeScript/LoadTypeScript.js

@@ -0,0 +1,14 @@
+import { VError } from '@lvce-editor/verror'
+
+export const loadTypeScript = async (typescriptPath) => {
+  try {
+    const typescript = await import(typescriptPath)
+    const actual = typescript.default
+    if (!actual) {
+      throw new Error('missing default export')
+    }
+    return actual
+  } catch (error) {
+    throw new VError(error, `Failed to load typescript`)
+  }
+}

package/src/parts/Main/Main.js

@@ -0,0 +1,8 @@
+import * as CommandMap from '../CommandMap/CommandMap.js'
+import * as CommandState from '../CommandState/CommandState.js'
+import * as Listen from '../Listen/Listen.js'
+
+export const main = async () => {
+  CommandState.registerCommands(CommandMap.commandMap)
+  await Listen.listen()
+}

package/src/parts/Path/Path.js

@@ -0,0 +1,21 @@
+import * as NodePath from 'node:path'
+
+export const join = (...parts) => {
+  return NodePath.join(...parts)
+}
+
+export const dirname = (path) => {
+  return NodePath.dirname(path)
+}
+
+export const basename = (path) => {
+  return NodePath.basename(path)
+}
+
+export const resolve = (path) => {
+  return NodePath.resolve(path)
+}
+
+export const isAbsolute = (path) => {
+  return NodePath.isAbsolute(path)
+}

package/src/parts/Platform/Platform.js

@@ -0,0 +1,5 @@
+export const isProduction = false
+
+export const isArchLinux = false
+
+export const isAppImage = false

package/src/parts/PlatformPaths/PlatformPaths.js

@@ -0,0 +1,6 @@
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+
+export const getBuiltinExtensionsPath = () => {
+  return process.env.BUILTIN_EXTENSIONS_PATH || Path.join(Root.root, 'extensions')
+}

package/src/parts/Root/Root.js

@@ -0,0 +1,6 @@
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export const root = resolve(__dirname, '../../../../../')

package/src/parts/TranspileTypeScript/TranspileTypeScript.js

@@ -0,0 +1,20 @@
+import { VError } from '@lvce-editor/verror'
+import * as Assert from '../Assert/Assert.js'
+import * as GetTypeScriptPath from '../GetTypeScriptPath/GetTypeScriptPath.js'
+import * as LoadTypeScript from '../LoadTypeScript/LoadTypeScript.js'
+
+export const transpileTypeScript = async (code) => {
+  try {
+    Assert.string(code)
+    const typescriptUri = GetTypeScriptPath.getTypeScriptUri()
+    const typescript = await LoadTypeScript.loadTypeScript(typescriptUri)
+    const newContent = await typescript.transpileModule(code, {
+      compilerOptions: {
+        target: 'esnext',
+      },
+    })
+    return newContent
+  } catch (error) {
+    throw new VError(error, `Failed to transpile typescript`)
+  }
+}

package/src/typescriptCompileProcessMain.js

@@ -0,0 +1,3 @@
+import * as Main from './parts/Main/Main.js'
+
+Main.main()