@lvce-editor/shared-process 0.37.5 → 0.37.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.37.5",
+  "version": "0.37.6",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "^1.3.0",
-    "@lvce-editor/extension-host-helper-process": "0.37.5",
+    "@lvce-editor/extension-host-helper-process": "0.37.6",
     "@lvce-editor/ipc": "^11.0.1",
     "@lvce-editor/json-rpc": "^4.2.0",
     "@lvce-editor/jsonc-parser": "^1.5.0",

package/src/parts/FileSystemDisk/FileSystemDisk.ipc.js

@@ -0,0 +1,15 @@
+import * as FileSystemDisk from './FileSystemDisk.js';
+export const name = 'FileSystemDisk';
+export const Commands = {
+    chmod: FileSystemDisk.chmod,
+    copy: FileSystemDisk.copy,
+    getPathSeparator: FileSystemDisk.getPathSeparator,
+    mkdir: FileSystemDisk.mkdir,
+    readDirWithFileTypes: FileSystemDisk.readDirWithFileTypes,
+    readFile: FileSystemDisk.readFile,
+    readJson: FileSystemDisk.readJson,
+    remove: FileSystemDisk.remove,
+    rename: FileSystemDisk.rename,
+    stat: FileSystemDisk.stat,
+    writeFile: FileSystemDisk.writeFile,
+};

package/src/parts/FileSystemDisk/FileSystemDisk.js

@@ -0,0 +1,247 @@
+// 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 { VError } from '../VError/VError.js';
+import { fileURLToPath } from 'node:url';
+const assertUri = (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}"`);
+    }
+};
+/**
+ *
+ * @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}"`);
+    }
+};
+/**
+ *
+ * @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}"`);
+    }
+};
+const isOkayToRemove = (path) => {
+    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}"`);
+    }
+};
+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}"`);
+    }
+};
+export const exists = async (uri) => {
+    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),
+    };
+};
+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}"`);
+    }
+};
+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}"`);
+    }
+};
+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}"`);
+    }
+};
+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}"`);
+    }
+};
+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}"`);
+    }
+};
+export const getPathSeparator = () => {
+    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;
+};
+export const chmod = async (uri, 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}`);
+    }
+};
+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}`);
+    }
+};
+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}"`);
+    }
+};

package/src/parts/Module/Module.js

@@ -133,6 +133,8 @@ export const load = (moduleId) => {
             return import('../WebViewServer/WebViewServer.ipc.js');
         case ModuleId.GetExtensions:
             return import('../GetExtensions/GetExtensions.ipc.js');
+        case ModuleId.FileSystemDisk:
+            return import('../FileSystemDisk/FileSystemDisk.ipc.js');
         default:
             throw new Error(`module ${moduleId} not found`);
     }

package/src/parts/ModuleId/ModuleId.js

@@ -70,3 +70,4 @@ export const FileWatcher = 75;
 export const WebViewServer = 76;
 export const Transferrable = 77;
 export const GetExtensions = 78;
+export const FileSystemDisk = 79;

package/src/parts/ModuleMap/ModuleMap.js

@@ -288,6 +288,18 @@ export const getModuleId = (commandId) => {
             return ModuleId.WebViewServer;
         case 'GetExtensions.getExtensions':
             return ModuleId.GetExtensions;
+        case 'FileSystemDisk.chmod':
+        case 'FileSystemDisk.copy':
+        case 'FileSystemDisk.getPathSeparator':
+        case 'FileSystemDisk.mkdir':
+        case 'FileSystemDisk.readDirWithFileTypes':
+        case 'FileSystemDisk.readFile':
+        case 'FileSystemDisk.remove':
+        case 'FileSystemDisk.rename':
+        case 'FileSystemDisk.stat':
+        case 'FileSystemDisk.readJson':
+        case 'FileSystemDisk.writeFile':
+            return ModuleId.FileSystemDisk;
         default:
             throw new CommandNotFoundError(commandId);
     }

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.37.5';
-export const commit = '57c2788';
-export const date = '2024-10-25T22:31:28.000Z';
+export const version = '0.37.6';
+export const commit = 'c3b8288';
+export const date = '2024-10-27T13:16:47.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/ResolveRoot/ResolveRoot.js

@@ -0,0 +1,73 @@
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import * as Env from '../Env/Env.js';
+import * as GetWorkspaceId from '../GetWorkspaceId/GetWorkspaceId.js';
+import * as IsAbsolutePath from '../IsAbsolutePath/IsAbsolutePath.js';
+import * as IsElectron from '../IsElectron/IsElectron.js';
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+import * as Platform from '../Platform/Platform.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as Root from '../Root/Root.js';
+import * as WorkspaceSource from '../WorkspaceSource/WorkspaceSource.js';
+const getAbsolutePath = (path) => {
+    if (IsAbsolutePath.isAbsolutePath(path)) {
+        return path;
+    }
+    if (path.startsWith('${cwd}')) {
+        path = Root.root + path.slice(5);
+    }
+    else if (path.startsWith('~')) {
+        path = `${homedir()}${path.slice(1)}`;
+    }
+    path = resolve(path);
+    return path;
+};
+const toUri = (path) => {
+    return pathToFileURL(path).toString();
+};
+export const resolveRoot = async () => {
+    if (IsElectron.isElectron) {
+        const argv = await ParentIpc.invoke('Process.getArgv');
+        const relevantArgv = argv.slice(2);
+        const last = relevantArgv.at(-1);
+        if (last && isAbsolute(last)) {
+            return {
+                path: last,
+                uri: toUri(last),
+                workspaceId: GetWorkspaceId.getWorkspaceId(last),
+                homeDir: PlatformPaths.getHomeDir(),
+                homeDirUri: toUri(PlatformPaths.getHomeDir()),
+                pathSeparator: Platform.getPathSeparator(),
+                source: 'shared-process-default',
+            };
+        }
+    }
+    // TODO shared process should have no logic, this should probably be somewhere else
+    const folder = Env.getFolder();
+    if (!folder) {
+        const path = join(Root.root, 'playground');
+        return {
+            path,
+            uri: toUri(path),
+            workspaceId: GetWorkspaceId.getWorkspaceId(path),
+            homeDir: PlatformPaths.getHomeDir(),
+            homeDirUri: toUri(PlatformPaths.getHomeDir()),
+            pathSeparator: Platform.getPathSeparator(),
+            source: WorkspaceSource.SharedProcessEnv,
+        };
+    }
+    const absolutePath = getAbsolutePath(folder);
+    const workspaceId = GetWorkspaceId.getWorkspaceId(absolutePath);
+    // TODO this slows down startup a lot (~30-50ms)
+    // const workspaceStorage = await getWorkspaceStorage(workspaceId)
+    return {
+        path: absolutePath,
+        uri: toUri(absolutePath),
+        workspaceId,
+        homeDir: PlatformPaths.getHomeDir(),
+        homeDirUri: toUri(PlatformPaths.getHomeDir()),
+        pathSeparator: Platform.getPathSeparator(),
+        source: WorkspaceSource.SharedProcessDefault,
+    };
+};

package/src/parts/Workspace/Workspace.js

@@ -1,28 +1,8 @@
 import { homedir } from 'node:os';
-import { isAbsolute, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import * as Env from '../Env/Env.js';
-import * as GetWorkspaceId from '../GetWorkspaceId/GetWorkspaceId.js';
-import * as IsAbsolutePath from '../IsAbsolutePath/IsAbsolutePath.js';
-import * as IsElectron from '../IsElectron/IsElectron.js';
-import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+import { fileURLToPath } from 'node:url';
 import * as Platform from '../Platform/Platform.js';
 import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
-import * as Root from '../Root/Root.js';
-import * as WorkspaceSource from '../WorkspaceSource/WorkspaceSource.js';
-const getAbsolutePath = (path) => {
-    if (IsAbsolutePath.isAbsolutePath(path)) {
-        return path;
-    }
-    if (path.startsWith('${cwd}')) {
-        path = Root.root + path.slice(5);
-    }
-    else if (path.startsWith('~')) {
-        path = `${homedir()}${path.slice(1)}`;
-    }
-    path = resolve(path);
-    return path;
-};
+import * as ResolveRoot from '../ResolveRoot/ResolveRoot.js';
 /**
  * @deprecated use platform instead
  */
@@ -33,51 +13,7 @@ export const getHomeDir = () => {
     const homeDir = homedir();
     return homeDir;
 };
-const toUri = (path) => {
-    return pathToFileURL(path).toString();
-};
-export const resolveRoot = async () => {
-    if (IsElectron.isElectron) {
-        const argv = await ParentIpc.invoke('Process.getArgv');
-        const relevantArgv = argv.slice(2);
-        const last = relevantArgv.at(-1);
-        if (last && isAbsolute(last)) {
-            return {
-                path: last,
-                uri: toUri(last),
-                workspaceId: GetWorkspaceId.getWorkspaceId(last),
-                homeDir: PlatformPaths.getHomeDir(),
-                pathSeparator: Platform.getPathSeparator(),
-                source: 'shared-process-default',
-            };
-        }
-    }
-    // TODO shared process should have no logic, this should probably be somewhere else
-    const folder = Env.getFolder();
-    if (!folder) {
-        const path = join(Root.root, 'playground');
-        return {
-            path,
-            uri: toUri(path),
-            workspaceId: GetWorkspaceId.getWorkspaceId(path),
-            homeDir: PlatformPaths.getHomeDir(),
-            pathSeparator: Platform.getPathSeparator(),
-            source: WorkspaceSource.SharedProcessEnv,
-        };
-    }
-    const absolutePath = getAbsolutePath(folder);
-    const workspaceId = GetWorkspaceId.getWorkspaceId(absolutePath);
-    // TODO this slows down startup a lot (~30-50ms)
-    // const workspaceStorage = await getWorkspaceStorage(workspaceId)
-    return {
-        path: absolutePath,
-        uri: toUri(absolutePath),
-        workspaceId,
-        homeDir: PlatformPaths.getHomeDir(),
-        pathSeparator: Platform.getPathSeparator(),
-        source: WorkspaceSource.SharedProcessDefault,
-    };
-};
+export const resolveRoot = ResolveRoot.resolveRoot;
 export const resolveUri = (uri) => {
     const path = fileURLToPath(uri);
     return {