@lvce-editor/shared-process 0.85.2 → 0.86.0

package/src/parts/FileSystemDisk/FileSystemDisk.js

@@ -1,253 +1,262 @@
 // TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as Assert from '../Assert/Assert.js';
-import * as EncodingType from '../EncodingType/EncodingType.js';
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
-import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js';
-import * as GetDirentType from '../GetDirentType/GetDirentType.js';
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
-import * as Trash from '../Trash/Trash.js';
-import * as GetFolderSizeInternal from '../GetFolderSizeInternal/GetFolderSizeInternal.js';
-import { VError } from '../VError/VError.js';
-import { fileURLToPath } from 'node:url';
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as Assert from '../Assert/Assert.js'
+import * as EncodingType from '../EncodingType/EncodingType.js'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
+import * as GetDirentType from '../GetDirentType/GetDirentType.js'
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
+import * as Trash from '../Trash/Trash.js'
+import * as GetFolderSizeInternal from '../GetFolderSizeInternal/GetFolderSizeInternal.js'
+import { VError } from '../VError/VError.js'
+import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+
 const assertUri = (uri) => {
-    if (!uri.startsWith('file://')) {
-        throw new Error(`path must be a valid file uri`);
-    }
-};
+  if (!uri.startsWith('file://')) {
+    throw new Error(`path must be a valid file uri`)
+  }
+}
+
 export const copy = async (sourceUri, targetUri) => {
-    try {
-        assertUri(sourceUri);
-        assertUri(targetUri);
-        const source = fileURLToPath(sourceUri);
-        const target = fileURLToPath(targetUri);
-        await fs.cp(source, target, { recursive: true });
-    }
-    catch (error) {
-        if (error && error.message && error.message.startsWith('Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)')) {
-            throw new VError(`Failed to copy "${sourceUri}" to "${targetUri}": src and dest cannot be the same`);
-        }
-        throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`);
-    }
-};
+  try {
+    assertUri(sourceUri)
+    assertUri(targetUri)
+    const source = fileURLToPath(sourceUri)
+    const target = fileURLToPath(targetUri)
+    await fs.cp(source, target, { recursive: true })
+  } catch (error) {
+    if (error && error.message && error.message.startsWith('Invalid src or dest: cp returned EINVAL (src and dest cannot be the same)')) {
+      throw new VError(`Failed to copy "${sourceUri}" to "${targetUri}": src and dest cannot be the same`)
+    }
+    throw new VError(error, `Failed to copy "${sourceUri}" to "${targetUri}"`)
+  }
+}
+
 /**
  *
  * @param {string} uri
  * @param {BufferEncoding} encoding
  * @returns
  */
-export const readFile = async (uri, encoding = EncodingType.Utf8) => {
-    try {
-        Assert.string(uri);
-        assertUri(uri);
-        const path = fileURLToPath(uri);
-        const content = await fs.readFile(path, encoding);
-        return content;
-    }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error)) {
-            throw new FileNotFoundError(uri);
-        }
-        throw new VError(error, `Failed to read file "${uri}"`);
-    }
-};
+export const readFile = async (uri, encoding      = EncodingType.Utf8) => {
+  try {
+    Assert.string(uri)
+    assertUri(uri)
+    const path = fileURLToPath(uri)
+    const content = await fs.readFile(path, encoding)
+    return content
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error)) {
+      throw new FileNotFoundError(uri)
+    }
+    throw new VError(error, `Failed to read file "${uri}"`)
+  }
+}
+
 /**
  *
  * @param {string} uri
  * @param {string} content
  * @param {BufferEncoding} encoding
  */
-export const writeFile = async (uri, content, encoding = EncodingType.Utf8) => {
-    try {
-        assertUri(uri);
-        Assert.string(uri);
-        Assert.string(content);
-        const path = fileURLToPath(uri);
-        // queue would be more correct for concurrent writes but also slower
-        // Queue.add(`writeFile/${path}`, () =>
-        await fs.writeFile(path, content, encoding);
-    }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error)) {
-            throw new FileNotFoundError(uri);
-        }
-        throw new VError(error, `Failed to write to file "${uri}"`);
-    }
-};
+export const writeFile = async (uri, content, encoding      = EncodingType.Utf8) => {
+  try {
+    assertUri(uri)
+    Assert.string(uri)
+    Assert.string(content)
+    const path = fileURLToPath(uri)
+    // queue would be more correct for concurrent writes but also slower
+    // Queue.add(`writeFile/${path}`, () =>
+    await fs.writeFile(path, content, encoding)
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error)) {
+      throw new FileNotFoundError(uri)
+    }
+    throw new VError(error, `Failed to write to file "${uri}"`)
+  }
+}
+
 const isOkayToRemove = (path) => {
-    if (path === '/') {
-        return false;
-    }
-    if (path === '~') {
-        return false;
-    }
-    if (path === os.homedir()) {
-        return false;
-    }
-    return true;
-};
+  if (path === '/') {
+    return false
+  }
+  if (path === '~') {
+    return false
+  }
+  if (path === os.homedir()) {
+    return false
+  }
+  return true
+}
+
 export const remove = async (uri) => {
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    if (!isOkayToRemove(path)) {
-        console.warn('not removing path');
-        return;
-    }
-    // TODO lazyload trash (doesn't work currently because of bug with jest)
-    // const { trash } = await import('../../wrap/trash.js')
-    try {
-        await Trash.trash(path);
-    }
-    catch (error) {
-        throw new VError(error, `Failed to remove "${uri}"`);
-    }
-};
+  assertUri(uri)
+  const path = fileURLToPath(uri)
+  if (!isOkayToRemove(path)) {
+    console.warn('not removing path')
+    return
+  }
+
+  // TODO lazyload trash (doesn't work currently because of bug with jest)
+  // const { trash } = await import('../../wrap/trash.js')
+  try {
+    await Trash.trash(path)
+  } catch (error) {
+    throw new VError(error, `Failed to remove "${uri}"`)
+  }
+}
+
 export const forceRemove = async (uri) => {
-    assertUri(uri);
-    const path = fileURLToPath(uri);
-    if (!isOkayToRemove(path)) {
-        console.warn('not removing path');
-        return;
-    }
-    try {
-        await fs.rm(path, { force: true, recursive: true });
-    }
-    catch (error) {
-        throw new VError(error, `Failed to remove "${uri}"`);
-    }
-};
+  assertUri(uri)
+  const path = fileURLToPath(uri)
+  if (!isOkayToRemove(path)) {
+    console.warn('not removing path')
+    return
+  }
+  try {
+    await fs.rm(path, { force: true, recursive: true })
+  } catch (error) {
+    throw new VError(error, `Failed to remove "${uri}"`)
+  }
+}
+
 export const exists = async (uri) => {
-    try {
-        assertUri(uri);
-        const path = fileURLToPath(uri);
-        await fs.access(uri);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
+  try {
+    assertUri(uri)
+    const path = fileURLToPath(uri)
+    await fs.access(uri)
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * @param {import('fs').Dirent} dirent
  */
 const toPrettyDirent = (dirent) => {
-    return {
-        name: dirent.name,
-        type: GetDirentType.getDirentType(dirent),
-    };
-};
+  return {
+    name: dirent.name,
+    type: GetDirentType.getDirentType(dirent),
+  }
+}
+
 export const readDirWithFileTypes = async (uri) => {
-    try {
-        assertUri(uri);
-        const path = fileURLToPath(uri);
-        const dirents = await fs.readdir(path, { withFileTypes: true });
-        const prettyDirents = dirents.map(toPrettyDirent);
-        return prettyDirents;
-    }
-    catch (error) {
-        throw new VError(error, `Failed to read directory "${uri}"`);
-    }
-};
+  try {
+    assertUri(uri)
+    const path = fileURLToPath(uri)
+    const dirents = await fs.readdir(path, { withFileTypes: true })
+    const prettyDirents = dirents.map(toPrettyDirent)
+    return prettyDirents
+  } catch (error) {
+    throw new VError(error, `Failed to read directory "${uri}"`)
+  }
+}
+
 export const readDir = async (uri) => {
-    try {
-        const path = fileURLToPath(uri);
-        const dirents = await fs.readdir(path);
-        return dirents;
-    }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error)) {
-            throw new FileNotFoundError(uri);
-        }
-        throw new VError(error, `Failed to read directory "${uri}"`);
-    }
-};
+  try {
+    const path = fileURLToPath(uri)
+    const dirents = await fs.readdir(path)
+    return dirents
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error)) {
+      throw new FileNotFoundError(uri)
+    }
+    throw new VError(error, `Failed to read directory "${uri}"`)
+  }
+}
+
 export const mkdir = async (uri) => {
-    try {
-        assertUri(uri);
-        const path = fileURLToPath(uri);
-        await fs.mkdir(path, { recursive: true });
-    }
-    catch (error) {
-        throw new VError(error, `Failed to create directory "${uri}"`);
-    }
-};
+  try {
+    assertUri(uri)
+    const path = fileURLToPath(uri)
+    await fs.mkdir(path, { recursive: true })
+  } catch (error) {
+    throw new VError(error, `Failed to create directory "${uri}"`)
+  }
+}
+
 const fallbackRename = async (oldUri, newUri) => {
-    try {
-        const oldPath = fileURLToPath(oldUri);
-        const newPath = fileURLToPath(newUri);
-        await fs.cp(oldPath, newPath, { recursive: true });
-        await fs.rm(oldPath, { recursive: true });
-    }
-    catch (error) {
-        throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
-    }
-};
+  try {
+    const oldPath = fileURLToPath(oldUri)
+    const newPath = fileURLToPath(newUri)
+    await fs.cp(oldPath, newPath, { recursive: true })
+    await fs.rm(oldPath, { recursive: true })
+  } catch (error) {
+    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`)
+  }
+}
+
 export const rename = async (oldUri, newUri) => {
-    try {
-        const oldPath = fileURLToPath(oldUri);
-        const newPath = fileURLToPath(newUri);
-        await fs.rename(oldPath, newPath);
-    }
-    catch (error) {
-        if (error && error.code === ErrorCodes.EXDEV) {
-            return fallbackRename(oldUri, newUri);
-        }
-        throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`);
-    }
-};
+  try {
+    const oldPath = fileURLToPath(oldUri)
+    const newPath = fileURLToPath(newUri)
+    await fs.rename(oldPath, newPath)
+  } catch (error) {
+    if (error && error.code === ErrorCodes.EXDEV) {
+      return fallbackRename(oldUri, newUri)
+    }
+    throw new VError(error, `Failed to rename "${oldUri}" to "${newUri}"`)
+  }
+}
+
 export const getPathSeparator = () => {
-    return '/';
-};
+  return '/'
+}
+
 // TODO handle error
 export const stat = async (uri) => {
-    const path = fileURLToPath(uri);
-    const stats = await fs.stat(path);
-    const type = GetDirentType.getDirentType(stats);
-    return type;
-};
+  const path = fileURLToPath(uri)
+  const stats = await fs.stat(path)
+  const type = GetDirentType.getDirentType(stats)
+  return type
+}
+
 export const chmod = async (uri, permissions) => {
-    const path = fileURLToPath(uri);
-    await fs.chmod(path, permissions);
-};
+  const path = fileURLToPath(uri)
+  await fs.chmod(path, permissions)
+}
+
 export const copyFile = async (fromUri, toUri) => {
-    try {
-        const fromPath = fileURLToPath(fromUri);
-        const toPath = fileURLToPath(toUri);
-        await fs.copyFile(fromPath, toPath);
-    }
-    catch (error) {
-        throw new VError(error, `Failed to copy file from ${fromUri} to ${toUri}`);
-    }
-};
+  try {
+    const fromPath = fileURLToPath(fromUri)
+    const toPath = fileURLToPath(toUri)
+    await fs.copyFile(fromPath, toPath)
+  } catch (error) {
+    throw new VError(error, `Failed to copy file from ${fromUri} to ${toUri}`)
+  }
+}
+
 export const cp = async (fromUri, toUri) => {
-    try {
-        const fromPath = fileURLToPath(fromUri);
-        const toPath = fileURLToPath(toUri);
-        await fs.cp(fromPath, toPath, { recursive: true });
-    }
-    catch (error) {
-        throw new VError(error, `Failed to copy folder from ${fromUri} to ${toUri}`);
-    }
-};
+  try {
+    const fromPath = fileURLToPath(fromUri)
+    const toPath = fileURLToPath(toUri)
+    await fs.cp(fromPath, toPath, { recursive: true })
+  } catch (error) {
+    throw new VError(error, `Failed to copy folder from ${fromUri} to ${toUri}`)
+  }
+}
+
 export const readJson = async (uri) => {
-    try {
-        Assert.string(uri);
-        assertUri(uri);
-        const path = fileURLToPath(uri);
-        const content = await fs.readFile(path, 'utf8');
-        const parsed = JSON.parse(content);
-        return parsed;
-    }
-    catch (error) {
-        if (IsEnoentError.isEnoentError(error)) {
-            throw new FileNotFoundError(uri);
-        }
-        throw new VError(error, `Failed to read file as json "${uri}"`);
-    }
-};
+  try {
+    Assert.string(uri)
+    assertUri(uri)
+    const path = fileURLToPath(uri)
+    const content = await fs.readFile(path, 'utf8')
+    const parsed = JSON.parse(content)
+    return parsed
+  } catch (error) {
+    if (IsEnoentError.isEnoentError(error)) {
+      throw new FileNotFoundError(uri)
+    }
+    throw new VError(error, `Failed to read file as json "${uri}"`)
+  }
+}
+
 export const getFolderSize = async (uri) => {
-    const path = fileURLToPath(uri);
-    const total = await GetFolderSizeInternal.getFolderSizeInternal(path);
-    return total;
-};
+  const path = fileURLToPath(uri)
+  const total = await GetFolderSizeInternal.getFolderSizeInternal(path)
+  return total
+}

package/src/parts/FileSystemProcess/FileSystemProcess.js

@@ -1,19 +1,22 @@
-import * as LaunchFileSystemProcess from '../LaunchFileSystemProcess/LaunchFileSystemProcess.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
-export const state = {
-    /**
-     * @type {any}
-     */
-    ipc: undefined,
-};
+import * as LaunchFileSystemProcess from '../LaunchFileSystemProcess/LaunchFileSystemProcess.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
+export const state      = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+}
+
 // TODO use createLazyRpc
 export const getOrCreate = async () => {
-    if (!state.ipc) {
-        state.ipc = LaunchFileSystemProcess.launchFileSystemProcess();
-    }
-    return state.ipc;
-};
+  if (!state.ipc) {
+    state.ipc = LaunchFileSystemProcess.launchFileSystemProcess()
+  }
+  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/FileSystemProcessPath/FileSystemProcessPath.js

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

package/src/parts/FileWatcher/FileWatcher.ipc.js

@@ -1,7 +1,9 @@
-import * as FileWatcher from '../FileWatcher/FileWatcher.js';
-export const name = 'FileWatcher';
+import * as FileWatcher from '../FileWatcher/FileWatcher.js'
+
+export const name = 'FileWatcher'
+
 export const Commands = {
-    watch: FileWatcher.watch,
-    watchFile2: FileWatcher.watchFile2,
-    handleChange: FileWatcher.handleChange,
-};
+  watch: FileWatcher.watch,
+  watchFile2: FileWatcher.watchFile2,
+  handleChange: FileWatcher.handleChange,
+}

package/src/parts/FileWatcher/FileWatcher.js

@@ -1,41 +1,46 @@
-import * as FileWatcherProcess from '../FileWatcherProcess/FileWatcherProcess.js';
-import * as Id from '../Id/Id.js';
-import * as JsonRpc from '../JsonRpc/JsonRpc.js';
+import * as FileWatcherProcess from '../FileWatcherProcess/FileWatcherProcess.js'
+import * as Id from '../Id/Id.js'
+import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+
 const handleEvents = (id, ipc, event) => {
-    JsonRpc.send(ipc, 'FileWatcher.handleEvent', id, event);
-};
+  JsonRpc.send(ipc, 'FileWatcher.handleEvent', id, event)
+}
+
 // handle the case when multiple windows create a file watcher with same id, ids should not collide
 // TODO remove ipc and dispose file watcher when socket / messageport closes
-const internalIdMap = Object.create(null);
-export const watch = async (ipc, id, { roots, exclude }) => {
-    const internalId = Id.create();
-    internalIdMap[internalId] = { id, ipc };
-    await FileWatcherProcess.invoke('FileWatcher.watchFolders', {
-        id: internalId,
-        roots,
-        exclude,
-    });
-};
+const internalIdMap = Object.create(null)
+
+export const watch = async (ipc, id, { roots, exclude }     ) => {
+  const internalId = Id.create()
+  internalIdMap[internalId] = { id, ipc }
+  await FileWatcherProcess.invoke('FileWatcher.watchFolders', {
+    id: internalId,
+    roots,
+    exclude,
+  })
+}
+
 const disposeFileWatcher = async (internalId) => {
-    try {
-        await FileWatcherProcess.invoke('FileWatcher.dispose', internalId);
-    }
-    catch {
-        // ignore
-    }
-};
+  try {
+    await FileWatcherProcess.invoke('FileWatcher.dispose', internalId)
+  } catch {
+    // ignore
+  }
+}
+
 export const watchFile2 = async (ipc, id, uri) => {
-    const internalId = Id.create();
-    const handleClose = async () => {
-        ipc.off('close', handleClose);
-        await disposeFileWatcher(internalId);
-    };
-    ipc.on('close', handleClose);
-    internalIdMap[internalId] = { id, ipc };
-    // TODO promise never resolves, should resolve as soon as watcher has been set up
-    await FileWatcherProcess.invoke('FileWatcher.watchFile2', internalId, uri);
-};
+  const internalId = Id.create()
+  const handleClose = async () => {
+    ipc.off('close', handleClose)
+    await disposeFileWatcher(internalId)
+  }
+  ipc.on('close', handleClose)
+  internalIdMap[internalId] = { id, ipc }
+  // TODO promise never resolves, should resolve as soon as watcher has been set up
+  await FileWatcherProcess.invoke('FileWatcher.watchFile2', internalId, uri)
+}
+
 export const handleChange = (event) => {
-    const ref = internalIdMap[event.id];
-    handleEvents(ref.id, ref.ipc, event);
-};
+  const ref = internalIdMap[event.id]
+  handleEvents(ref.id, ref.ipc, event)
+}