@lvce-editor/shared-process 0.25.9 → 0.25.11

package/src/parts/FileSystem/FileSystem.js

@@ -1,34 +1,31 @@
 // 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 Path from '../Path/Path.js'
-import * as Platform from '../Platform/Platform.js'
-import * as Trash from '../Trash/Trash.js'
-import { VError } from '../VError/VError.js'
-
+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 Path from '../Path/Path.js';
+import * as Platform from '../Platform/Platform.js';
+import * as Trash from '../Trash/Trash.js';
+import { VError } from '../VError/VError.js';
 export const state = {
-  watcherMap: Object.create(null),
-}
-
+    watcherMap: Object.create(null),
+};
 export const copy = async (source, target) => {
-  try {
-    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 "${source}" to "${target}": src and dest cannot be the same`)
-    }
-    throw new VError(error, `Failed to copy "${source}" to "${target}"`)
-  }
-}
-
+    try {
+        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 "${source}" to "${target}": src and dest cannot be the same`);
+        }
+        throw new VError(error, `Failed to copy "${source}" to "${target}"`);
+    }
+};
 // TODO extensions should only be accessed once on startup
-
 /**
  *
  * @param {string} path
@@ -36,24 +33,24 @@ export const copy = async (source, target) => {
  * @returns
  */
 export const readFile = async (path, encoding = EncodingType.Utf8) => {
-  // console.info('[shared-process] read file', path)
-  try {
-    Assert.string(path)
-    // const start = performance.now()
-    // console.time(`read ${path}`)
-    const content = await fs.readFile(path, encoding)
-    // const end = performance.now()
-    // console.log('read', path, 'took', (end - start).toFixed(2), 'ms')
-    // console.timeEnd(`read ${path}`)
-    return content
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      throw new FileNotFoundError(path)
-    }
-    throw new VError(error, `Failed to read file "${path}"`)
-  }
-}
-
+    // console.info('[shared-process] read file', path)
+    try {
+        Assert.string(path);
+        // const start = performance.now()
+        // console.time(`read ${path}`)
+        const content = await fs.readFile(path, encoding);
+        // const end = performance.now()
+        // console.log('read', path, 'took', (end - start).toFixed(2), 'ms')
+        // console.timeEnd(`read ${path}`)
+        return content;
+    }
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            throw new FileNotFoundError(path);
+        }
+        throw new VError(error, `Failed to read file "${path}"`);
+    }
+};
 /**
  *
  * @param {string} path
@@ -61,154 +58,151 @@ export const readFile = async (path, encoding = EncodingType.Utf8) => {
  * @param {BufferEncoding} encoding
  */
 export const writeFile = async (path, content, encoding = EncodingType.Utf8) => {
-  try {
-    Assert.string(path)
-    Assert.string(content)
-    // 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(path)
-    }
-    throw new VError(error, `Failed to write to file "${path}"`)
-  }
-}
-
+    try {
+        Assert.string(path);
+        Assert.string(content);
+        // 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(path);
+        }
+        throw new VError(error, `Failed to write to file "${path}"`);
+    }
+};
 export const ensureFile = async (path, content) => {
-  try {
-    await fs.mkdir(Path.dirname(path), { recursive: true })
-    await fs.writeFile(path, content)
-  } catch (error) {
-    throw new VError(error, `Failed to write to file "${path}"`)
-  }
-}
-
+    try {
+        await fs.mkdir(Path.dirname(path), { recursive: true });
+        await fs.writeFile(path, content);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to write to file "${path}"`);
+    }
+};
 export const createFile = async (path) => {
-  try {
-    await fs.writeFile(path, '', { flag: 'wx' })
-  } catch (error) {
-    throw new VError(error, `Failed to create file "${path}"`)
-  }
-}
-
+    try {
+        await fs.writeFile(path, '', { flag: 'wx' });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to create file "${path}"`);
+    }
+};
 export const createFolder = async (path, options) => {
-  try {
-    await fs.mkdir(path, options)
-  } catch (error) {
-    throw new VError(error, `Failed to create folder "${path}"`)
-  }
-}
-
+    try {
+        await fs.mkdir(path, options);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to create folder "${path}"`);
+    }
+};
 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 (path) => {
-  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 "${path}"`)
-  }
-}
-
+    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 "${path}"`);
+    }
+};
 export const forceRemove = async (path) => {
-  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 "${path}"`)
-  }
-}
-
+    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 "${path}"`);
+    }
+};
 export const exists = async (path) => {
-  try {
-    await fs.access(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
+    try {
+        await fs.access(path);
+        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 (path) => {
-  try {
-    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 "${path}"`)
-  }
-}
-
+    try {
+        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 "${path}"`);
+    }
+};
 export const readDir = async (path) => {
-  try {
-    const dirents = await fs.readdir(path)
-    return dirents
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      throw new FileNotFoundError(path)
-    }
-    throw new VError(error, `Failed to read directory "${path}"`)
-  }
-}
-
+    try {
+        const dirents = await fs.readdir(path);
+        return dirents;
+    }
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            throw new FileNotFoundError(path);
+        }
+        throw new VError(error, `Failed to read directory "${path}"`);
+    }
+};
 export const mkdir = async (path) => {
-  try {
-    await fs.mkdir(path, { recursive: true })
-  } catch (error) {
-    throw new VError(error, `Failed to create directory "${path}"`)
-  }
-}
-
+    try {
+        await fs.mkdir(path, { recursive: true });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to create directory "${path}"`);
+    }
+};
 const fallbackRename = async (oldPath, newPath) => {
-  try {
-    await fs.cp(oldPath, newPath, { recursive: true })
-    await fs.rm(oldPath, { recursive: true })
-  } catch (error) {
-    throw new VError(error, `Failed to rename "${oldPath}" to "${newPath}"`)
-  }
-}
-
+    try {
+        await fs.cp(oldPath, newPath, { recursive: true });
+        await fs.rm(oldPath, { recursive: true });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to rename "${oldPath}" to "${newPath}"`);
+    }
+};
 export const rename = async (oldPath, newPath) => {
-  try {
-    await fs.rename(oldPath, newPath)
-  } catch (error) {
-    if (error && error.code === ErrorCodes.EXDEV) {
-      return fallbackRename(oldPath, newPath)
-    }
-    throw new VError(error, `Failed to rename "${oldPath}" to "${newPath}"`)
-  }
-}
-
+    try {
+        await fs.rename(oldPath, newPath);
+    }
+    catch (error) {
+        if (error && error.code === ErrorCodes.EXDEV) {
+            return fallbackRename(oldPath, newPath);
+        }
+        throw new VError(error, `Failed to rename "${oldPath}" to "${newPath}"`);
+    }
+};
 // TODO have a separate process for file watching
 // export const watch = async (path, options) => {
 //   // let state = 'loading'
@@ -216,78 +210,70 @@ export const rename = async (oldPath, newPath) => {
 //   const watcher = chokidar.watch(`${path}`, {
 //     ignoreInitial: true,
 //   })
-
 //   if (options.onAll) {
 //     watcher.on('all', options.onAll)
 //   }
 //   return watcher
-
 //   // const { default: chokidar } = await import('chokidar')
 // }
-
 export const getPathSeparator = () => {
-  return Platform.getPathSeparator()
-}
-
+    return Platform.getPathSeparator();
+};
 export const getRealPath = async (path) => {
-  try {
-    return await fs.realpath(path)
-  } catch (error) {
-    // @ts-ignore
-    if (
-      error &&
-      error instanceof globalThis.Error &&
-      // @ts-ignore
-      error.code === ErrorCodes.ENOENT
-    ) {
-      let content
-      try {
-        content = await fs.readlink(path)
-      } catch {
-        throw new VError(error, `Failed to resolve real path for ${path}`)
-      }
-      throw new VError(`Broken symbolic link: File not found ${content}`)
-    }
-    throw new VError(error, `Failed to resolve real path for ${path}`)
-  }
-}
-
+    try {
+        return await fs.realpath(path);
+    }
+    catch (error) {
+        // @ts-ignore
+        if (error &&
+            error instanceof globalThis.Error &&
+            // @ts-ignore
+            error.code === ErrorCodes.ENOENT) {
+            let content;
+            try {
+                content = await fs.readlink(path);
+            }
+            catch {
+                throw new VError(error, `Failed to resolve real path for ${path}`);
+            }
+            throw new VError(`Broken symbolic link: File not found ${content}`);
+        }
+        throw new VError(error, `Failed to resolve real path for ${path}`);
+    }
+};
 // TODO handle error
 export const stat = async (path) => {
-  const stats = await fs.stat(path)
-  const type = GetDirentType.getDirentType(stats)
-  return type
-}
-
+    const stats = await fs.stat(path);
+    const type = GetDirentType.getDirentType(stats);
+    return type;
+};
 export const chmod = async (path, permissions) => {
-  await fs.chmod(path, permissions)
-}
+    await fs.chmod(path, permissions);
+};
 export const copyFile = async (from, to) => {
-  try {
-    await fs.copyFile(from, to)
-  } catch (error) {
-    throw new VError(error, `Failed to copy file from ${from} to ${to}`)
-  }
-}
-
+    try {
+        await fs.copyFile(from, to);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to copy file from ${from} to ${to}`);
+    }
+};
 export const cp = async (from, to) => {
-  try {
-    await fs.cp(from, to, { recursive: true })
-  } catch (error) {
-    throw new VError(error, `Failed to copy folder from ${from} to ${to}`)
-  }
-}
-
+    try {
+        await fs.cp(from, to, { recursive: true });
+    }
+    catch (error) {
+        throw new VError(error, `Failed to copy folder from ${from} to ${to}`);
+    }
+};
 // export const unwatch = (id) => {
 //   state.watchers[id].close()
 //   delete state.watchers[id]
 // }
-
 // export const unwatchAll = () => {
 //   for (const key in state.watchers) {
 //     unwatch(key)
 //   }
 // }
-
 // TODO ui should show useful error message when file cannot be saved
 // and for permission denied error it should use that npm module that allows root

package/src/parts/FileSystemWatch/FileSystemWatch.js

@@ -1,6 +1,5 @@
-import * as fs from 'node:fs/promises'
-
+import * as fs from 'node:fs/promises';
 export const watchFile = (path) => {
-  const watcher = fs.watch(path)
-  return watcher
-}
+    const watcher = fs.watch(path);
+    return watcher;
+};

package/src/parts/FirstNodeWorkerEventType/FirstNodeWorkerEventType.js

@@ -1,3 +1,3 @@
-export const Exit = 1
-export const Error = 2
-export const Message = 3
+export const Exit = 1;
+export const Error = 2;
+export const Message = 3;

package/src/parts/GetAccurateMemoryUsage/GetAccurateMemoryUsage.js

@@ -1,39 +1,39 @@
-import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import * as Assert from '../Assert/Assert.js'
-import * as EncodingType from '../EncodingType/EncodingType.js'
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js'
-import * as ParseMemory from '../ParseMemory/ParseMemory.js'
-import * as Platform from '../Platform/Platform.js'
-import { VError } from '../VError/VError.js'
-
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as Assert from '../Assert/Assert.js';
+import * as EncodingType from '../EncodingType/EncodingType.js';
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as IsEsrchError from '../IsEsrchError/IsEsrchError.js';
+import * as ParseMemory from '../ParseMemory/ParseMemory.js';
+import * as Platform from '../Platform/Platform.js';
+import { VError } from '../VError/VError.js';
 const getContent = async (pid) => {
-  try {
-    const filePath = join('/proc', `${pid}`, 'statm')
-    const content = await readFile(filePath, EncodingType.Utf8)
-    return content
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error) || IsEsrchError.isEsrchError(error)) {
-      return ''
+    try {
+        const filePath = join('/proc', `${pid}`, 'statm');
+        const content = await readFile(filePath, EncodingType.Utf8);
+        return content;
     }
-    throw error
-  }
-}
-
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error) || IsEsrchError.isEsrchError(error)) {
+            return '';
+        }
+        throw error;
+    }
+};
 export const getAccurateMemoryUsage = async (pid) => {
-  try {
-    Assert.number(pid)
-    if (Platform.isMacOs) {
-      return 0
+    try {
+        Assert.number(pid);
+        if (Platform.isMacOs) {
+            return 0;
+        }
+        const content = await getContent(pid);
+        if (!content) {
+            return -1;
+        }
+        const memory = ParseMemory.parseMemory(content);
+        return memory;
     }
-    const content = await getContent(pid)
-    if (!content) {
-      return -1
+    catch (error) {
+        throw new VError(error, 'Failed to get accurate memory usage');
     }
-    const memory = ParseMemory.parseMemory(content)
-    return memory
-  } catch (error) {
-    throw new VError(error, 'Failed to get accurate memory usage')
-  }
-}
+};

package/src/parts/GetAppImageDownloadUrl/GetAppImageDownloadUrl.js

@@ -1,6 +1,5 @@
-import * as Assert from '../Assert/Assert.js'
-
+import * as Assert from '../Assert/Assert.js';
 export const getDownloadUrl = (repository, version, appImageName) => {
-  Assert.string(version)
-  return `https://github.com/${repository}/releases/download/v${version}/${appImageName}-v${version}.AppImage`
-}
+    Assert.string(version);
+    return `https://github.com/${repository}/releases/download/v${version}/${appImageName}-v${version}.AppImage`;
+};

package/src/parts/GetAppImagePath/GetAppImagePath.js

@@ -1,5 +1,4 @@
-import * as Env from '../Env/Env.js'
-
+import * as Env from '../Env/Env.js';
 export const getAppImagePath = () => {
-  return Env.getAppImagePath()
-}
+    return Env.getAppImagePath();
+};