@lvce-editor/shared-process 0.25.9 → 0.25.11

package/src/parts/ExtensionManifest/ExtensionManifest.js

@@ -1,55 +1,57 @@
-import isObject from 'is-object'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as InferExtensionId from '../InferExtensionId/InferExtensionId.js'
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as ReadJson from '../JsonFile/JsonFile.js'
-import * as Path from '../Path/Path.js'
-import { VError } from '../VError/VError.js'
-
+import isObject from 'is-object';
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+import * as InferExtensionId from '../InferExtensionId/InferExtensionId.js';
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as ReadJson from '../JsonFile/JsonFile.js';
+import * as Path from '../Path/Path.js';
+import { VError } from '../VError/VError.js';
 // TODO json parsing and error handling should happen in renderer process
 export const get = async (path) => {
-  const absolutePath = Path.join(path, 'extension.json')
-  try {
-    const json = await ReadJson.readJson(absolutePath)
-    if (!isObject(json)) {
-      // TODO should include stack of extension json file here
-      throw new VError('Invalid manifest file: Not an JSON object.')
-    }
-    return {
-      ...json,
-      path,
-      status: ExtensionManifestStatus.Resolved,
-    }
-  } catch (error) {
-    const id = InferExtensionId.inferExtensionId(path)
-    const enhancedError = new VError(error, `Failed to load extension manifest for ${id}`)
-    if (IsEnoentError.isEnoentError(error)) {
-      try {
-        const monoRepoPath = Path.join(path, `packages`, 'extension', 'extension.json')
-        const json = await ReadJson.readJson(monoRepoPath)
+    const absolutePath = Path.join(path, 'extension.json');
+    try {
+        const json = await ReadJson.readJson(absolutePath);
         if (!isObject(json)) {
-          // TODO should include stack of extension json file here
-          throw new VError('Invalid manifest file: Not an JSON object.')
+            // TODO should include stack of extension json file here
+            throw new VError('Invalid manifest file: Not an JSON object.');
         }
         return {
-          ...json,
-          path: Path.join(path, 'packages', 'extension'),
-          status: ExtensionManifestStatus.Resolved,
-        }
-      } catch {}
-      // @ts-ignore
-      enhancedError.path = absolutePath
-      // @ts-ignore
-      enhancedError.code = ErrorCodes.E_MANIFEST_NOT_FOUND
-    } else {
-      // @ts-ignore
-      enhancedError.code = error.code
+            ...json,
+            path,
+            status: ExtensionManifestStatus.Resolved,
+        };
     }
-    return {
-      path,
-      status: ExtensionManifestStatus.Rejected,
-      reason: enhancedError,
+    catch (error) {
+        const id = InferExtensionId.inferExtensionId(path);
+        const enhancedError = new VError(error, `Failed to load extension manifest for ${id}`);
+        if (IsEnoentError.isEnoentError(error)) {
+            try {
+                const monoRepoPath = Path.join(path, `packages`, 'extension', 'extension.json');
+                const json = await ReadJson.readJson(monoRepoPath);
+                if (!isObject(json)) {
+                    // TODO should include stack of extension json file here
+                    throw new VError('Invalid manifest file: Not an JSON object.');
+                }
+                return {
+                    ...json,
+                    path: Path.join(path, 'packages', 'extension'),
+                    status: ExtensionManifestStatus.Resolved,
+                };
+            }
+            catch { }
+            // @ts-ignore
+            enhancedError.path = absolutePath;
+            // @ts-ignore
+            enhancedError.code = ErrorCodes.E_MANIFEST_NOT_FOUND;
+        }
+        else {
+            // @ts-ignore
+            enhancedError.code = error.code;
+        }
+        return {
+            path,
+            status: ExtensionManifestStatus.Rejected,
+            reason: enhancedError,
+        };
     }
-  }
-}
+};

package/src/parts/ExtensionManifestInputType/ExtensionManifestInputType.js

@@ -1,5 +1,3 @@
-export const Folder = 1
-
-export const OnlyExtension = 2
-
-export const LinkedExtensionsFolder = 3
+export const Folder = 1;
+export const OnlyExtension = 2;
+export const LinkedExtensionsFolder = 3;

package/src/parts/ExtensionManifestStatus/ExtensionManifestStatus.js

@@ -1,3 +1,2 @@
-export const Resolved = 'resolved'
-
-export const Rejected = 'rejected'
+export const Resolved = 'resolved';
+export const Rejected = 'rejected';

package/src/parts/ExtensionManifests/ExtensionManifests.js

@@ -1,45 +1,41 @@
-import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
-import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js'
-import * as ExtensionManifestsGetFromLinkedExtensionsFolder from './ExtensionManifestsFromLinkedExtensionsFolder.js'
-import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js'
-
+import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js';
+import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js';
+import * as ExtensionManifestsGetFromLinkedExtensionsFolder from './ExtensionManifestsFromLinkedExtensionsFolder.js';
+import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js';
 const getModule = (type) => {
-  switch (type) {
-    case ExtensionManifestInputType.Folder:
-      return ExtensionManifestsGetFromFolder
-    case ExtensionManifestInputType.OnlyExtension:
-      return ExtensionManifestsGetFromOnlyExtension
-    case ExtensionManifestInputType.LinkedExtensionsFolder:
-      return ExtensionManifestsGetFromLinkedExtensionsFolder
-    default:
-      throw new Error('unsupported input type')
-  }
-}
-
+    switch (type) {
+        case ExtensionManifestInputType.Folder:
+            return ExtensionManifestsGetFromFolder;
+        case ExtensionManifestInputType.OnlyExtension:
+            return ExtensionManifestsGetFromOnlyExtension;
+        case ExtensionManifestInputType.LinkedExtensionsFolder:
+            return ExtensionManifestsGetFromLinkedExtensionsFolder;
+        default:
+            throw new Error('unsupported input type');
+    }
+};
 const get = (input) => {
-  const module = getModule(input.type)
-  return module.getExtensionManifests(input.path)
-}
-
+    const module = getModule(input.type);
+    return module.getExtensionManifests(input.path);
+};
 const deduplicateExtensions = (extensions, builtinExtensionsPath) => {
-  const seen = Object.create(null)
-  const uniqueExtensions = []
-  for (const extension of extensions) {
-    if (extension.id in seen) {
-      continue
-    }
-    seen[extension.id] = true
-    if (extension.path.startsWith(builtinExtensionsPath)) {
-      extension.builtin = true
+    const seen = Object.create(null);
+    const uniqueExtensions = [];
+    for (const extension of extensions) {
+        if (extension.id in seen) {
+            continue;
+        }
+        seen[extension.id] = true;
+        if (extension.path.startsWith(builtinExtensionsPath)) {
+            extension.builtin = true;
+        }
+        uniqueExtensions.push(extension);
     }
-    uniqueExtensions.push(extension)
-  }
-  return uniqueExtensions
-}
-
+    return uniqueExtensions;
+};
 export const getAll = async (inputs, builtinExtensionsPath) => {
-  const manifests = await Promise.all(inputs.map(get))
-  const flatManifests = manifests.flat(1)
-  const uniqueExtensions = deduplicateExtensions(flatManifests, builtinExtensionsPath)
-  return uniqueExtensions
-}
+    const manifests = await Promise.all(inputs.map(get));
+    const flatManifests = manifests.flat(1);
+    const uniqueExtensions = deduplicateExtensions(flatManifests, builtinExtensionsPath);
+    return uniqueExtensions;
+};

package/src/parts/ExtensionManifests/ExtensionManifestsFromFolder.js

@@ -1,22 +1,22 @@
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
-import { VError } from '../VError/VError.js'
-
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js';
+import { VError } from '../VError/VError.js';
 export const getExtensionManifests = async (path) => {
-  try {
-    if (!path) {
-      return []
+    try {
+        if (!path) {
+            return [];
+        }
+        const dirents = await FileSystem.readDir(path);
+        const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, dirents);
+        const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get));
+        return manifests;
     }
-    const dirents = await FileSystem.readDir(path)
-    const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, dirents)
-    const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
-    return manifests
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      return []
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            return [];
+        }
+        throw new VError(error, 'Failed to get extension manifests');
     }
-    throw new VError(error, 'Failed to get extension manifests')
-  }
-}
+};

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtensionsFolder.js

@@ -1,54 +1,53 @@
-import { readlink } from 'node:fs/promises'
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
-import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
-import { VError } from '../VError/VError.js'
-
+import { readlink } from 'node:fs/promises';
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
+import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js';
+import { VError } from '../VError/VError.js';
 const readSymlink = async (absolutePath) => {
-  try {
-    const info = await readlink(absolutePath)
-    return info
-  } catch {
-    return ''
-  }
-}
-
+    try {
+        const info = await readlink(absolutePath);
+        return info;
+    }
+    catch {
+        return '';
+    }
+};
 const readSymlinks = (absolutePaths) => {
-  return Promise.all(absolutePaths.map(readSymlink))
-}
-
+    return Promise.all(absolutePaths.map(readSymlink));
+};
 const mergeWithSymLinks = (manifests, symlinks) => {
-  const { length } = manifests
-  const merged = []
-  for (let i = 0; i < length; i++) {
-    const manifest = manifests[i]
-    const symlink = symlinks[i]
-    if (manifest.status === ExtensionManifestStatus.Rejected) {
-      merged.push(manifest)
-    } else {
-      merged.push({ ...manifest, symlink })
+    const { length } = manifests;
+    const merged = [];
+    for (let i = 0; i < length; i++) {
+        const manifest = manifests[i];
+        const symlink = symlinks[i];
+        if (manifest.status === ExtensionManifestStatus.Rejected) {
+            merged.push(manifest);
+        }
+        else {
+            merged.push({ ...manifest, symlink });
+        }
     }
-  }
-  return merged
-}
-
+    return merged;
+};
 export const getExtensionManifests = async (path) => {
-  try {
-    if (!path) {
-      return []
+    try {
+        if (!path) {
+            return [];
+        }
+        const dirents = await FileSystem.readDir(path);
+        const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, dirents);
+        const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get));
+        const symlinks = await readSymlinks(absolutePaths);
+        const merged = mergeWithSymLinks(manifests, symlinks);
+        return merged;
     }
-    const dirents = await FileSystem.readDir(path)
-    const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, dirents)
-    const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
-    const symlinks = await readSymlinks(absolutePaths)
-    const merged = mergeWithSymLinks(manifests, symlinks)
-    return merged
-  } catch (error) {
-    if (IsEnoentError.isEnoentError(error)) {
-      return []
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            return [];
+        }
+        throw new VError(error, 'Failed to get extension manifests');
     }
-    throw new VError(error, 'Failed to get extension manifests')
-  }
-}
+};

package/src/parts/ExtensionManifests/ExtensionManifestsFromOnlyExtension.js

@@ -1,9 +1,8 @@
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
-
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
 export const getExtensionManifests = async (path) => {
-  if (path) {
-    const manifest = await ExtensionManifest.get(path)
-    return [manifest]
-  }
-  return []
-}
+    if (path) {
+        const manifest = await ExtensionManifest.get(path);
+        return [manifest];
+    }
+    return [];
+};

package/src/parts/ExtensionUninstall/ExtensionUninstall.js

@@ -1,18 +1,18 @@
-import { rm } from 'node:fs/promises'
-import * as Debug from '../Debug/Debug.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import { VError } from '../VError/VError.js'
-
+import { rm } from 'node:fs/promises';
+import * as Debug from '../Debug/Debug.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import { VError } from '../VError/VError.js';
 export const uninstall = async (id) => {
-  try {
-    Debug.debug(`ExtensionManagement#uninstall ${id}`)
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    await rm(Path.join(extensionsPath, id), { recursive: true })
-  } catch (error) {
-    // if (error.code === 'ENOENT') {
-    //   return
-    // }
-    throw new VError(error, `Failed to uninstall extension "${id}"`)
-  }
-}
+    try {
+        Debug.debug(`ExtensionManagement#uninstall ${id}`);
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        await rm(Path.join(extensionsPath, id), { recursive: true });
+    }
+    catch (error) {
+        // if (error.code === 'ENOENT') {
+        //   return
+        // }
+        throw new VError(error, `Failed to uninstall extension "${id}"`);
+    }
+};

package/src/parts/ExtensionUnlink/ExtensionUnlink.js

@@ -1,21 +1,21 @@
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import * as RemoveSymlink from '../RemoveSymlink/RemoveSymlink.js'
-import { VError } from '../VError/VError.js'
-
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as RemoveSymlink from '../RemoveSymlink/RemoveSymlink.js';
+import { VError } from '../VError/VError.js';
 export const unlink = async (path) => {
-  try {
-    const manifest = await ExtensionManifest.get(path)
-    if (manifest.status === ExtensionManifestStatus.Rejected) {
-      throw manifest.reason
+    try {
+        const manifest = await ExtensionManifest.get(path);
+        if (manifest.status === ExtensionManifestStatus.Rejected) {
+            throw manifest.reason;
+        }
+        const linkedExtensionsPath = PlatformPaths.getLinkedExtensionsPath();
+        // @ts-ignore
+        const to = Path.join(linkedExtensionsPath, manifest.id);
+        await RemoveSymlink.removeSymlink(to);
     }
-    const linkedExtensionsPath = PlatformPaths.getLinkedExtensionsPath()
-    // @ts-ignore
-    const to = Path.join(linkedExtensionsPath, manifest.id)
-    await RemoveSymlink.removeSymlink(to)
-  } catch (error) {
-    throw new VError(error, `Failed to unlink extension`)
-  }
-}
+    catch (error) {
+        throw new VError(error, `Failed to unlink extension`);
+    }
+};

package/src/parts/Extract/Extract.js

@@ -1,30 +1,26 @@
-import { createReadStream } from 'node:fs'
-import { mkdir } from 'node:fs/promises'
-import { pipeline } from 'node:stream/promises'
-import { createBrotliDecompress, createGunzip } from 'node:zlib'
-import tar from 'tar-fs'
-import { VError } from '../VError/VError.js'
-
+import { createReadStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { pipeline } from 'node:stream/promises';
+import { createBrotliDecompress, createGunzip } from 'node:zlib';
+import tar from 'tar-fs';
+import { VError } from '../VError/VError.js';
 export const extractTarBr = async (inFile, outDir) => {
-  try {
-    await mkdir(outDir, { recursive: true })
-    await pipeline(createReadStream(inFile), createBrotliDecompress(), tar.extract(outDir))
-  } catch (error) {
-    throw new VError(error, `Failed to extract ${inFile}`)
-  }
-}
-
+    try {
+        await mkdir(outDir, { recursive: true });
+        await pipeline(createReadStream(inFile), createBrotliDecompress(), tar.extract(outDir));
+    }
+    catch (error) {
+        throw new VError(error, `Failed to extract ${inFile}`);
+    }
+};
 export const extractTarGz = async ({ inFile, outDir, strip }) => {
-  try {
-    await mkdir(outDir, { recursive: true })
-    await pipeline(
-      createReadStream(inFile),
-      createGunzip(),
-      tar.extract(outDir, {
-        strip,
-      }),
-    )
-  } catch (error) {
-    throw new VError(error, `Failed to extract ${inFile}`)
-  }
-}
+    try {
+        await mkdir(outDir, { recursive: true });
+        await pipeline(createReadStream(inFile), createGunzip(), tar.extract(outDir, {
+            strip,
+        }));
+    }
+    catch (error) {
+        throw new VError(error, `Failed to extract ${inFile}`);
+    }
+};

package/src/parts/FileNotFoundError/FileNotFoundError.js

@@ -1,16 +1,14 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import { VError } from '../VError/VError.js'
-
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import { VError } from '../VError/VError.js';
 const getDisplayPath = (path) => {
-  if (path === '') {
-    return '<empty string>'
-  }
-  return path
-}
-
+    if (path === '') {
+        return '<empty string>';
+    }
+    return path;
+};
 export class FileNotFoundError extends VError {
-  constructor(path) {
-    super(`File not found: '${getDisplayPath(path)}'`)
-    this.code = ErrorCodes.ENOENT
-  }
+    constructor(path) {
+        super(`File not found: '${getDisplayPath(path)}'`);
+        this.code = ErrorCodes.ENOENT;
+    }
 }

package/src/parts/FileSystem/FileSystem.ipc.js

@@ -1,34 +1,31 @@
-import * as FileSystem from './FileSystem.js'
-
+import * as FileSystem from './FileSystem.js';
 // TODO ugly code here -> should be inside FileSystem.js
 const fileSystemWatch = (socket, id, path) => {
-  // const watcher = FileSystem.watch(path, {
-  //   onAll(...args) {
-  //     socket.send(JSON.stringify([/* callback */ id, /* event */ args]))
-  //   }
-  // }
-  // )
-  // socket.on('close', () => {
-  //   watcher.close()
-  // })
-}
-
-export const name = 'FileSystem'
-
+    // const watcher = FileSystem.watch(path, {
+    //   onAll(...args) {
+    //     socket.send(JSON.stringify([/* callback */ id, /* event */ args]))
+    //   }
+    // }
+    // )
+    // socket.on('close', () => {
+    //   watcher.close()
+    // })
+};
+export const name = 'FileSystem';
 // TODO separate ipc from code like in renderer worker
 export const Commands = {
-  chmod: FileSystem.chmod,
-  copy: FileSystem.copy,
-  createFile: FileSystem.createFile,
-  createFolder: FileSystem.createFolder,
-  ensureFile: FileSystem.ensureFile,
-  getPathSeparator: FileSystem.getPathSeparator,
-  getRealPath: FileSystem.getRealPath,
-  mkdir: FileSystem.mkdir,
-  readDirWithFileTypes: FileSystem.readDirWithFileTypes,
-  readFile: FileSystem.readFile,
-  remove: FileSystem.remove,
-  rename: FileSystem.rename,
-  stat: FileSystem.stat,
-  writeFile: FileSystem.writeFile,
-}
+    chmod: FileSystem.chmod,
+    copy: FileSystem.copy,
+    createFile: FileSystem.createFile,
+    createFolder: FileSystem.createFolder,
+    ensureFile: FileSystem.ensureFile,
+    getPathSeparator: FileSystem.getPathSeparator,
+    getRealPath: FileSystem.getRealPath,
+    mkdir: FileSystem.mkdir,
+    readDirWithFileTypes: FileSystem.readDirWithFileTypes,
+    readFile: FileSystem.readFile,
+    remove: FileSystem.remove,
+    rename: FileSystem.rename,
+    stat: FileSystem.stat,
+    writeFile: FileSystem.writeFile,
+};