@lvce-editor/shared-process 0.85.3 → 0.86.0

package/src/parts/Transferrables/Transferrables.js

@@ -1,4 +1,5 @@
-import * as IsMessagePort from '../IsMessagePort/IsMessagePort.js';
-import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js';
-import * as IsSocket from '../IsSocket/IsSocket.js';
-export const transferrables = [IsMessagePort.isMessagePort, IsMessagePortMain.isMessagePortMain, IsSocket.isSocket];
+import * as IsMessagePort from '../IsMessagePort/IsMessagePort.js'
+import * as IsMessagePortMain from '../IsMessagePortMain/IsMessagePortMain.js'
+import * as IsSocket from '../IsSocket/IsSocket.js'
+
+export const transferrables = [IsMessagePort.isMessagePort, IsMessagePortMain.isMessagePortMain, IsSocket.isSocket]

package/src/parts/TransientLinkedExtensions/TransientLinkedExtensions.js

@@ -1,66 +1,72 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
-import * as FileSystem from '../FileSystem/FileSystem.js';
-import * as Path from '../Path/Path.js';
-import * as Process from '../Process/Process.js';
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Path from '../Path/Path.js'
+import * as Process from '../Process/Process.js'
+
 const getCliLinkArgs = () => {
-    const links = [];
-    const argv = Process.argv.slice(2);
-    for (let i = 0; i < argv.length; i++) {
-        const arg = argv[i];
-        if (arg === '--link') {
-            const value = argv[i + 1];
-            links.push({
-                path: value || '',
-                source: '--link',
-            });
-            i++;
-            continue;
-        }
-        if (arg.startsWith('--link=')) {
-            links.push({
-                path: arg.slice('--link='.length),
-                source: '--link',
-            });
-        }
+  const links        = []
+  const argv = Process.argv.slice(2)
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--link') {
+      const value = argv[i + 1]
+      links.push({
+        path: value || '',
+        source: '--link',
+      })
+      i++
+      continue
     }
-    return links;
-};
-const resolveLinkPath = (path) => {
-    if (Path.isAbsolute(path)) {
-        return path;
+    if (arg.startsWith('--link=')) {
+      links.push({
+        path: arg.slice('--link='.length),
+        source: '--link',
+      })
     }
-    return Path.join(Process.cwd(), path);
-};
+  }
+  return links
+}
+
+const resolveLinkPath = (path) => {
+  if (Path.isAbsolute(path)) {
+    return path
+  }
+  return Path.join(Process.cwd(), path)
+}
+
 export const getLinkedExtensions = () => {
-    return getCliLinkArgs().map((link) => {
-        return {
-            ...link,
-            resolvedPath: resolveLinkPath(link.path),
-        };
-    });
-};
+  return getCliLinkArgs().map((link) => {
+    return {
+      ...link,
+      resolvedPath: resolveLinkPath(link.path),
+    }
+  })
+}
+
 const createMissingPathError = (link) => {
-    const error = new Error(`Failed to start: ${link.source} requires a folder path`);
-    // @ts-ignore
-    error.code = ErrorCodes.ENOENT;
-    return error;
-};
+  const error = new Error(`Failed to start: ${link.source} requires a folder path`)
+  // @ts-ignore
+  error.code = ErrorCodes.ENOENT
+  return error
+}
+
 const createPathNotFoundError = (link) => {
-    const message = link.path === link.resolvedPath ? link.path : `${link.path} (resolved to ${link.resolvedPath})`;
-    const error = new Error(`Failed to start: ${link.source} path does not exist: ${message}`);
-    // @ts-ignore
-    error.code = ErrorCodes.ENOENT;
-    return error;
-};
+  const message = link.path === link.resolvedPath ? link.path : `${link.path} (resolved to ${link.resolvedPath})`
+  const error = new Error(`Failed to start: ${link.source} path does not exist: ${message}`)
+  // @ts-ignore
+  error.code = ErrorCodes.ENOENT
+  return error
+}
+
 export const validate = async () => {
-    const links = getLinkedExtensions();
-    for (const link of links) {
-        if (!link.path) {
-            throw createMissingPathError(link);
-        }
-        if (!(await FileSystem.exists(link.resolvedPath))) {
-            throw createPathNotFoundError(link);
-        }
+  const links = getLinkedExtensions()
+  for (const link of links) {
+    if (!link.path) {
+      throw createMissingPathError(link)
+    }
+    if (!(await FileSystem.exists(link.resolvedPath))) {
+      throw createPathNotFoundError(link)
     }
-    return links;
-};
+  }
+  return links
+}

package/src/parts/TranspileTypeScript/TranspileTypeScript.js

@@ -1,8 +1,9 @@
-import * as TypeScriptCompileProcess from '../TypeScriptCompileProcess/TypeScriptCompileProcess.js';
-import * as TranspileTypeScriptCached from '../TranspileTypeScriptCached/TranspileTypeScriptCached.js';
+import * as TypeScriptCompileProcess from '../TypeScriptCompileProcess/TypeScriptCompileProcess.js'
+import * as TranspileTypeScriptCached from '../TranspileTypeScriptCached/TranspileTypeScriptCached.js'
+
 export const transpileTypeScript = (code, useCache) => {
-    if (useCache) {
-        return TranspileTypeScriptCached.transpileTypeScriptCached(code);
-    }
-    return TypeScriptCompileProcess.invoke('TranspileTypeScript.transpileTypeScript2', code);
-};
+  if (useCache) {
+    return TranspileTypeScriptCached.transpileTypeScriptCached(code)
+  }
+  return TypeScriptCompileProcess.invoke('TranspileTypeScript.transpileTypeScript2', code)
+}

package/src/parts/TranspileTypeScriptCached/TranspileTypeScriptCached.js

@@ -1,20 +1,21 @@
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import * as Hash from '../Hash/Hash.js';
-import * as TypeScriptCompileCachePath from '../TypeScriptCompileCachePath/TypeScriptCompileCachePath.js';
-import * as TypeScriptCompileProcess from '../TypeScriptCompileProcess/TypeScriptCompileProcess.js';
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import * as Hash from '../Hash/Hash.js'
+import * as TypeScriptCompileCachePath from '../TypeScriptCompileCachePath/TypeScriptCompileCachePath.js'
+import * as TypeScriptCompileProcess from '../TypeScriptCompileProcess/TypeScriptCompileProcess.js'
+
 export const transpileTypeScriptCached = async (code) => {
-    const hash = Hash.fromString(code);
-    const cachePath = join(TypeScriptCompileCachePath.typescriptCompileCachePath, `${hash}.ts`);
-    if (!existsSync(cachePath)) {
-        const { outputText } = await TypeScriptCompileProcess.invoke('TranspileTypeScript.transpileTypeScript', code);
-        await mkdir(dirname(cachePath), { recursive: true });
-        await writeFile(cachePath, outputText);
-    }
-    const content = await readFile(cachePath, 'utf8');
-    return {
-        outputText: content,
-        diagnostics: [],
-    };
-};
+  const hash = Hash.fromString(code)
+  const cachePath = join(TypeScriptCompileCachePath.typescriptCompileCachePath, `${hash}.ts`)
+  if (!existsSync(cachePath)) {
+    const { outputText } = await TypeScriptCompileProcess.invoke('TranspileTypeScript.transpileTypeScript', code)
+    await mkdir(dirname(cachePath), { recursive: true })
+    await writeFile(cachePath, outputText)
+  }
+  const content = await readFile(cachePath, 'utf8')
+  return {
+    outputText: content,
+    diagnostics: [],
+  }
+}

package/src/parts/Trash/Trash.js

@@ -1,11 +1,13 @@
-import * as IsElectron from '../IsElectron/IsElectron.js';
+import * as IsElectron from '../IsElectron/IsElectron.js'
+
 const getModule = () => {
-    if (IsElectron.isElectron) {
-        return import('../TrashElectron/TrashElectron.js');
-    }
-    return import('../TrashNode/TrashNode.js');
-};
+  if (IsElectron.isElectron) {
+    return import('../TrashElectron/TrashElectron.js')
+  }
+  return import('../TrashNode/TrashNode.js')
+}
+
 export const trash = async (path) => {
-    const module = await getModule();
-    await module.trash(path);
-};
+  const module = await getModule()
+  await module.trash(path)
+}

package/src/parts/TrashElectron/TrashElectron.js

@@ -1,8 +1,9 @@
-import { existsSync } from 'node:fs';
-import * as ParentIpc from '../MainProcess/MainProcess.js';
+import { existsSync } from 'node:fs'
+import * as ParentIpc from '../MainProcess/MainProcess.js'
+
 export const trash = async (path) => {
-    if (!existsSync(path)) {
-        return;
-    }
-    await ParentIpc.invoke('Trash.trash', path);
-};
+  if (!existsSync(path)) {
+    return
+  }
+  await ParentIpc.invoke('Trash.trash', path)
+}

package/src/parts/TrashNode/TrashNode.js

@@ -1,10 +1,10 @@
-import { VError } from '@lvce-editor/verror';
-import _trash from 'trash';
+import { VError } from '@lvce-editor/verror'
+import _trash from 'trash'
+
 export const trash = async (path) => {
-    try {
-        await _trash(path);
-    }
-    catch (error) {
-        throw new VError(error, 'Failed to move item to trash');
-    }
-};
+  try {
+    await _trash(path)
+  } catch (error) {
+    throw new VError(error, 'Failed to move item to trash')
+  }
+}

package/src/parts/TypeScriptCompileCachePath/TypeScriptCompileCachePath.js

@@ -1,3 +1,4 @@
-import * as Path from '../Path/Path.js';
-import * as Root from '../Root/Root.js';
-export const typescriptCompileCachePath = Path.join(Root.root, 'packages', 'build', '.tmp', 'typescript-compile-cache');
+import * as Path from '../Path/Path.js'
+import * as Root from '../Root/Root.js'
+
+export const typescriptCompileCachePath = Path.join(Root.root, 'packages', 'build', '.tmp', 'typescript-compile-cache')

package/src/parts/TypeScriptCompileProcess/TypeScriptCompileProcess.js

@@ -1,18 +1,21 @@
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-import * as LaunchTypeScriptCompileProcess from '../LaunchTypeScriptCompileProcess/LaunchTypeScriptCompileProcess.js';
-export const state = {
-    /**
-     * @type {any}
-     */
-    ipc: undefined,
-};
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as LaunchTypeScriptCompileProcess from '../LaunchTypeScriptCompileProcess/LaunchTypeScriptCompileProcess.js'
+
+export const state      = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
 export const getOrCreate = async () => {
-    if (!state.ipc) {
-        state.ipc = LaunchTypeScriptCompileProcess.launchTypeScriptCompileProcess();
-    }
-    return state.ipc;
-};
+  if (!state.ipc) {
+    state.ipc = LaunchTypeScriptCompileProcess.launchTypeScriptCompileProcess()
+  }
+  return state.ipc
+}
+
 export const invoke = async (method, ...params) => {
-    const ipc = await getOrCreate();
-    return JsonRpc.invoke(ipc, method, ...params);
-};
+  const ipc = await getOrCreate()
+  return JsonRpc.invoke(ipc, method, ...params)
+}

package/src/parts/TypeScriptCompileProcessPath/TypeScriptCompileProcessPath.js

@@ -1,2 +1,3 @@
-import * as ResolveBin from '../ResolveBin/ResolveBin.js';
-export const typescriptCompileProcessPath = ResolveBin.resolveBin('@lvce-editor/typescript-compile-process');
+import * as ResolveBin from '../ResolveBin/ResolveBin.js'
+
+export const typescriptCompileProcessPath = ResolveBin.resolveBin('@lvce-editor/typescript-compile-process')

package/src/parts/UpdateState/UpdateState.js

@@ -1,10 +1,13 @@
-import * as UpdateStateType from '../UpdateStateType/UpdateStateType.js';
-export const state = {
-    updateState: UpdateStateType.Uninitialized,
-};
+import * as UpdateStateType from '../UpdateStateType/UpdateStateType.js'
+
+export const state      = {
+  updateState: UpdateStateType.Uninitialized,
+}
+
 export const get = () => {
-    return state.updateState;
-};
+  return state.updateState
+}
+
 export const set = (value) => {
-    state.updateState = value;
-};
+  state.updateState = value
+}

package/src/parts/UpdateStateType/UpdateStateType.js

@@ -1,9 +1,9 @@
-export const Uninitialized = 1;
-export const Idle = 2;
-export const Disabled = 3;
-export const CheckingForUpdates = 3;
-export const AvailableForDownload = 4;
-export const Downloading = 5;
-export const Downloaded = 6;
-export const Updating = 7;
-export const Ready = 8;
+export const Uninitialized = 1
+export const Idle = 2
+export const Disabled = 3
+export const CheckingForUpdates = 3
+export const AvailableForDownload = 4
+export const Downloading = 5
+export const Downloaded = 6
+export const Updating = 7
+export const Ready = 8

package/src/parts/V8CacheOptions/V8CacheOptions.js

@@ -1,2 +1,2 @@
-export const BypassHeatCheck = 'bypassHeatCheck';
-export const None = 'none';
+export const BypassHeatCheck = 'bypassHeatCheck'
+export const None = 'none'

package/src/parts/VError/VError.js

@@ -1 +1 @@
-export * from '@lvce-editor/verror';
+export * from '@lvce-editor/verror'

package/src/parts/WaitForProcessToExit/WaitForProcessToExit.js

@@ -1,8 +1,9 @@
-import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js';
-import * as ProcessExitEventType from '../ProcessExitEventType/ProcessExitEventType.js';
+import * as GetFirstEvent from '../GetFirstEvent/GetFirstEvent.js'
+import * as ProcessExitEventType from '../ProcessExitEventType/ProcessExitEventType.js'
+
 export const waitForProcessToExit = (childProcess) => {
-    return GetFirstEvent.getFirstEvent(childProcess, {
-        error: ProcessExitEventType.Error,
-        close: ProcessExitEventType.Exit,
-    });
-};
+  return GetFirstEvent.getFirstEvent(childProcess, {
+    error: ProcessExitEventType.Error,
+    close: ProcessExitEventType.Exit,
+  })
+}

package/src/parts/WalkValue/WalkValue.js

@@ -1,21 +1,21 @@
 export const walkValue = (value, transferrables, isTransferrable) => {
-    if (!value) {
-        return;
+  if (!value) {
+    return
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value)
+    return
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable)
     }
-    if (isTransferrable(value)) {
-        transferrables.push(value);
-        return;
+    return
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable)
     }
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            walkValue(item, transferrables, isTransferrable);
-        }
-        return;
-    }
-    if (typeof value === 'object') {
-        for (const property of Object.values(value)) {
-            walkValue(property, transferrables, isTransferrable);
-        }
-        return;
-    }
-};
+    return
+  }
+}

package/src/parts/WatchFile/WatchFile.js

@@ -1,14 +1,14 @@
-import { VError } from '@lvce-editor/verror';
-import * as fs from 'node:fs/promises';
+import { VError } from '@lvce-editor/verror'
+import * as fs from 'node:fs/promises'
+
 export const watchFile = async (path, callback) => {
-    try {
-        const watcher = fs.watch(path);
-        for await (const event of watcher) {
-            callback(event);
-        }
-        return watcher;
+  try {
+    const watcher = fs.watch(path)
+    for await (const event of watcher) {
+      callback(event)
     }
-    catch (error) {
-        console.error(`[shared-process] ${new VError(error, `Failed to watch file`)}`);
-    }
-};
+    return watcher
+  } catch (error) {
+    console.error(`[shared-process] ${new VError(error, `Failed to watch file`)}`)
+  }
+}

package/src/parts/WatchForHotReload/WatchForHotReload.js

@@ -1,17 +1,21 @@
-import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js';
-import * as FileSystemWatch from '../WatchFile/WatchFile.js';
-const hasWatcher = new WeakSet();
+import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
+import * as FileSystemWatch from '../WatchFile/WatchFile.js'
+
+const hasWatcher = new WeakSet()
+
 export const watchForHotReload = async (socket, configs) => {
-    if (hasWatcher.has(socket)) {
-        return;
-    }
-    hasWatcher.add(socket);
-    // TODO when socket closes, dispose file watcher?
-    // or keep file watcher and broadcast to all sockets?
-    await Promise.all(configs.map(async (config) => {
-        const callback = () => {
-            socket.send({ jsonrpc: JsonRpcVersion.Two, method: config.command, params: [] });
-        };
-        await FileSystemWatch.watchFile(config.path, callback);
-    }));
-};
+  if (hasWatcher.has(socket)) {
+    return
+  }
+  hasWatcher.add(socket)
+  // TODO when socket closes, dispose file watcher?
+  // or keep file watcher and broadcast to all sockets?
+  await Promise.all(
+    configs.map(async (config) => {
+      const callback = () => {
+        socket.send({ jsonrpc: JsonRpcVersion.Two, method: config.command, params: [] })
+      }
+      await FileSystemWatch.watchFile(config.path, callback)
+    }),
+  )
+}

package/src/parts/WebViewProtocolState/WebViewProtocolState.js

@@ -1,9 +1,10 @@
-const state = {
-    promise: undefined,
-};
+const state      = {
+  promise: undefined,
+}
+
 export const getOrCreate = (fn) => {
-    if (!state.promise) {
-        state.promise = fn();
-    }
-    return state.promise;
-};
+  if (!state.promise) {
+    state.promise = fn()
+  }
+  return state.promise
+}

package/src/parts/WebViewServer/WebViewServer.ipc.js

@@ -1,10 +1,12 @@
-import * as WebViewServer from '../WebViewServer/WebViewServer.js';
-export const name = 'WebViewServer';
+import * as WebViewServer from '../WebViewServer/WebViewServer.js'
+
+export const name = 'WebViewServer'
+
 export const Commands = {
-    start: WebViewServer.start,
-    create: WebViewServer.create,
-    setHandler: WebViewServer.setHandler,
-    registerProtocol: WebViewServer.registerProtocol,
-    setInfo: WebViewServer.setInfo,
-    setInfo2: WebViewServer.setInfo2,
-};
+  start: WebViewServer.start,
+  create: WebViewServer.create,
+  setHandler: WebViewServer.setHandler,
+  registerProtocol: WebViewServer.registerProtocol,
+  setInfo: WebViewServer.setInfo,
+  setInfo2: WebViewServer.setInfo2,
+}

package/src/parts/WebViewServer/WebViewServer.js

@@ -1,18 +1,30 @@
-import * as PreviewProcess from '../PreviewProcess/PreviewProcess.js';
-import * as RegisterWebViewProtocol from '../RegisterWebViewProtocol/RegisterWebViewProtocol.js';
-export const registerProtocol = RegisterWebViewProtocol.registerWebViewProtocol;
+import * as PreviewProcess from '../PreviewProcess/PreviewProcess.js'
+import * as RegisterWebViewProtocol from '../RegisterWebViewProtocol/RegisterWebViewProtocol.js'
+
+export const registerProtocol = RegisterWebViewProtocol.registerWebViewProtocol
+
 export const create = async (...args) => {
-    await PreviewProcess.invoke('WebViewServer.create', ...args);
-};
+  await PreviewProcess.invoke('WebViewServer.create', ...args)
+}
+
 export const start = async (previewId, port) => {
-    await PreviewProcess.invoke('WebViewServer.start', previewId, port);
-};
-export const setHandler = async (previewId, frameAncestors, webViewRoot, contentSecurityPolicy, iframeContent) => {
-    await PreviewProcess.invoke('WebViewServer.setHandler', previewId, frameAncestors, webViewRoot, contentSecurityPolicy, iframeContent);
-};
+  await PreviewProcess.invoke('WebViewServer.start', previewId, port)
+}
+
+export const setHandler = async (
+  previewId,
+  frameAncestors,
+  webViewRoot,
+  contentSecurityPolicy,
+  iframeContent,
+) => {
+  await PreviewProcess.invoke('WebViewServer.setHandler', previewId, frameAncestors, webViewRoot, contentSecurityPolicy, iframeContent)
+}
+
 export const setInfo = async (...args) => {
-    await PreviewProcess.invoke('WebViewServer.setInfo', ...args);
-};
+  await PreviewProcess.invoke('WebViewServer.setInfo', ...args)
+}
+
 export const setInfo2 = async (...args) => {
-    await PreviewProcess.invoke('WebViewServer.setInfo2', ...args);
-};
+  await PreviewProcess.invoke('WebViewServer.setInfo2', ...args)
+}

package/src/parts/Workspace/Workspace.ipc.js

@@ -1,6 +1,8 @@
-import * as Workspace from './Workspace.js';
-export const name = 'Workspace';
+import * as Workspace from './Workspace.js'
+
+export const name = 'Workspace'
+
 export const Commands = {
-    getHomeDir: Workspace.getHomeDir,
-    resolveRoot: Workspace.resolveRoot,
-};
+  getHomeDir: Workspace.getHomeDir,
+  resolveRoot: Workspace.resolveRoot,
+}