@lvce-editor/shared-process 0.85.1 → 0.85.3

package/index.js

@@ -4,14 +4,36 @@ const __dirname = import.meta.dirname
 
 export const sharedProcessPath = join(__dirname, 'src', 'sharedProcessMain.js')
 
-export const exportStatic = async ({ extensionPath = process.cwd(), testPath = '', root = '' } = {}) => {
+const toArray = (value) => {
+  if (!value) {
+    return []
+  }
+  if (Array.isArray(value)) {
+    return value
+  }
+  return [value]
+}
+
+const toAbsoluteExtensionPath = (root, extensionPath) => {
+  if (extensionPath && extensionPath !== root && !isAbsolute(extensionPath)) {
+    return join(root, extensionPath)
+  }
+  return extensionPath
+}
+
+/**
+ * @param {{extensionPath?: string, extensionPaths?: string[] | string, testPath?: string, root?: string}} [options]
+ */
+export const exportStatic = async (options = {}) => {
+  const { extensionPath, extensionPaths = [], testPath = '', root = '' } = options
   if (!root) {
     throw new Error(`root argument is required`)
   }
   const fn = await import('./src/parts/ExportStatic/ExportStatic.js')
-  if (extensionPath && extensionPath !== root && !isAbsolute(extensionPath)) {
-    extensionPath = join(root, extensionPath)
-  }
+  const extensionPathList = toArray(extensionPaths)
+  const defaultExtensionPath = extensionPath === undefined && extensionPathList.length === 0 ? process.cwd() : extensionPath
+  const absoluteExtensionPath = toAbsoluteExtensionPath(root, defaultExtensionPath)
+  const absoluteExtensionPaths = extensionPathList.map((extensionPath) => toAbsoluteExtensionPath(root, extensionPath))
   const pathPrefix = process.env.PATH_PREFIX || ''
-  return fn.exportStatic({ root, pathPrefix, extensionPath, testPath })
+  return fn.exportStatic({ root, pathPrefix, extensionPath: absoluteExtensionPath, extensionPaths: absoluteExtensionPaths, testPath })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.85.1",
+  "version": "0.85.3",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -19,7 +19,7 @@
   "dependencies": {
     "@lvce-editor/assert": "1.6.0",
     "@lvce-editor/auth-process": "1.6.0",
-    "@lvce-editor/extension-host-helper-process": "0.85.1",
+    "@lvce-editor/extension-host-helper-process": "0.85.3",
     "@lvce-editor/ipc": "16.1.0",
     "@lvce-editor/json-rpc": "8.1.0",
     "@lvce-editor/jsonc-parser": "1.5.0",

package/src/parts/AppWindow/AppWindow.js

@@ -7,7 +7,7 @@ import * as PreloadUrl from '../PreloadUrl/PreloadUrl.js';
 import * as Screen from '../Screen/Screen.js';
 export const createAppWindow = async ({ preferences, parsedArgs, workingDirectory, url = DefaultUrl.defaultUrl, preloadUrl }) => {
     const { width, height } = await Screen.getBounds();
-    const windowOptions = GetAppWindowOptions.getAppWindowOptions({
+    const windowOptions = await GetAppWindowOptions.getAppWindowOptions({
         preferences,
         screenWidth: width,
         screenHeight: height,

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -2,6 +2,6 @@ import { join } from 'path';
 import { fileURLToPath } from 'url';
 export const getBuiltinExtensionsPath = () => {
     const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'));
-    const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '6f0f9b3', 'extensions');
+    const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'bbc1fd1', 'extensions');
     return builtinExtensionsPath;
 };

package/src/parts/ElectronWindow/ElectronWindow.js

@@ -11,7 +11,7 @@ export const minimize = (windowId) => {
 };
 export const toggleDevtools = (windowId) => {
     Assert.number(windowId);
-    return ParentIpc.invoke('ElectronWindow.executeWebContentsFunction', windowId, 'toggleDevTools');
+    return ParentIpc.invoke('ElectronWindow.executeWindowFunction', windowId, 'toggleDevtools');
 };
 export const maximize = (windowId) => {
     Assert.number(windowId);

package/src/parts/ExportStatic/ExportStatic.js

@@ -1,4 +1,5 @@
 import { existsSync } from 'node:fs';
+import { stripTypeScriptTypes } from 'node:module';
 import { isAbsolute, join } from 'node:path';
 import * as FileSystem from '../FileSystem/FileSystem.js';
 import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
@@ -207,12 +208,14 @@ const addExtensionThemes = async ({ root, extensionPath, extensionJson, commitHa
     }
     for (const colorTheme of colorThemes) {
         const { id, path } = colorTheme;
-        await FileSystem.mkdir(Path.join(root, 'dist', commitHash, 'extensions', `builtin.theme-${id}`));
+        const extensionId = `builtin.theme-${id}`;
+        await FileSystem.forceRemove(Path.join(root, 'dist', commitHash, 'extensions', extensionId));
+        await FileSystem.mkdir(Path.join(root, 'dist', commitHash, 'extensions', extensionId));
         await FileSystem.copy(Path.join(extensionPath, path), Path.join(root, 'dist', commitHash, 'themes', `${id}.json`));
         await replace(Path.join(root, 'dist', commitHash, 'config', 'defaultSettings.json'), `"workbench.colorTheme": "slime"`, `"workbench.colorTheme": "${id}"`);
-        await FileSystem.copyFile(Path.join(root, 'README.md'), Path.join(root, 'dist', commitHash, 'extensions', `builtin.theme-${id}`, 'README.md'));
-        await FileSystem.copyFile(Path.join(extensionPath, 'extension.json'), Path.join(root, 'dist', commitHash, 'extensions', `builtin.theme-${id}`, 'extension.json'));
-        await FileSystem.copyFile(Path.join(extensionPath, 'color-theme.json'), Path.join(root, 'dist', commitHash, 'extensions', `builtin.theme-${id}`, 'color-theme.json'));
+        await FileSystem.copyFile(Path.join(root, 'README.md'), Path.join(root, 'dist', commitHash, 'extensions', extensionId, 'README.md'));
+        await FileSystem.copyFile(Path.join(extensionPath, 'extension.json'), Path.join(root, 'dist', commitHash, 'extensions', extensionId, 'extension.json'));
+        await FileSystem.copyFile(Path.join(extensionPath, 'color-theme.json'), Path.join(root, 'dist', commitHash, 'extensions', extensionId, 'color-theme.json'));
     }
     const themesJson = await JsonFile.readJson(Path.join(root, 'dist', commitHash, 'config', 'themes.json'));
     const ids = colorThemes.map(getId);
@@ -276,6 +279,28 @@ const addExtensionLanguages = async ({ root, extensionPath, extensionJson, commi
         await JsonFile.writeJson(Path.join(root, 'dist', commitHash, 'config', 'fileMap.json'), fileMap);
     }
 };
+export const mergeExtensionManifests = (manifests, extraExtensions) => {
+    const replacements = Object.create(null);
+    for (const extension of extraExtensions) {
+        replacements[extension.id] = extension;
+    }
+    const used = Object.create(null);
+    const merged = manifests.map((manifest) => {
+        const replacement = replacements[manifest.id];
+        if (replacement) {
+            used[manifest.id] = true;
+            return replacement;
+        }
+        return manifest;
+    });
+    for (const extension of extraExtensions) {
+        if (used[extension.id]) {
+            continue;
+        }
+        merged.push(extension);
+    }
+    return merged;
+};
 const updateExtensionsJson = async ({ root, commitHash, pathPrefix, extraExtensions }) => {
     const dirents = await FileSystem.readDir(Path.join(root, 'dist', commitHash, 'extensions'));
     const manifests = await Promise.all(dirents.map(async (dirent) => {
@@ -286,10 +311,13 @@ const updateExtensionsJson = async ({ root, commitHash, pathPrefix, extraExtensi
             path: webExtensionPath,
         };
     }));
-    for (const extension of extraExtensions) {
-        extension.path = `${pathPrefix}/${commitHash}/extensions/${extension.id}`;
-    }
-    const newExtensions = [...manifests, ...extraExtensions];
+    const localExtensions = extraExtensions.map((extension) => {
+        return {
+            ...extension,
+            path: `${pathPrefix}/${commitHash}/extensions/${extension.id}`,
+        };
+    });
+    const newExtensions = mergeExtensionManifests(manifests, localExtensions);
     await JsonFile.writeJson(Path.join(root, 'dist', commitHash, 'config', 'extensions.json'), newExtensions);
 };
 const addExtensionWebExtension = async ({ root, extensionPath, commitHash, extensionJson, pathPrefix, useSimpleWebExtensionFile }) => {
@@ -311,6 +339,7 @@ const addExtensionWebExtension = async ({ root, extensionPath, commitHash, exten
         },
     ];
     await JsonFile.writeJson(Path.join(root, 'dist', commitHash, 'config', 'webExtensions.json'), webExtensions);
+    await FileSystem.forceRemove(Path.join(root, 'dist', commitHash, 'extensions', extensionJson.id));
     for (const dirent of ['src', 'extension.json']) {
         await FileSystem.copy(Path.join(extensionPath, dirent), Path.join(root, 'dist', commitHash, 'extensions', extensionJson.id, dirent));
     }
@@ -385,21 +414,15 @@ const isTestFile = (file) => {
 const getTestFiles = (testFilesRaw) => {
     return testFilesRaw.filter(isTestFile).map(getName);
 };
-const transpileFile = (typescript, content) => {
-    const result = typescript.transpileModule(content, {
-        compilerOptions: {
-            target: 'esnext',
-        },
-    });
-    return result.outputText;
+export const transpileFile = (content) => {
+    return stripTypeScriptTypes(content);
 };
 const transpileFiles = async (folder) => {
-    const typescript = await import('typescript');
     const dirents = await readdir(folder);
     for (const dirent of dirents) {
         if (dirent.endsWith('.ts')) {
             const content = await readFile(join(folder, dirent), 'utf-8');
-            const js = transpileFile(typescript, content);
+            const js = transpileFile(content);
             await writeFile(join(folder, dirent.slice(0, -2) + 'js'), js);
         }
     }
@@ -499,21 +522,49 @@ const resolveServerStaticPath = (root) => {
     }
     throw new Error(`server static path not found`);
 };
+const toArray = (value) => {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [value];
+};
+const getExtensionPaths = (extensionPath, extensionPaths) => {
+    const seen = Object.create(null);
+    const allExtensionPaths = [];
+    for (const path of [...toArray(extensionPath), ...toArray(extensionPaths)]) {
+        if (!path || seen[path]) {
+            continue;
+        }
+        seen[path] = true;
+        allExtensionPaths.push(path);
+    }
+    return allExtensionPaths;
+};
 /**
  *
- * @param {{root:string, pathPrefix:string , extensionPath:string, testPath:string, useSimpleWebExtensionFile?:boolean, serverStaticPath?:string }} param0
+ * @param {{root:string, pathPrefix:string , extensionPath:string, extensionPaths?:string[], testPath:string, useSimpleWebExtensionFile?:boolean, serverStaticPath?:string }} param0
  */
-export const exportStatic = async ({ root, pathPrefix, extensionPath, testPath, useSimpleWebExtensionFile, serverStaticPath }) => {
+export const exportStatic = async ({ root, pathPrefix, extensionPath, extensionPaths, testPath, useSimpleWebExtensionFile, serverStaticPath }) => {
     if (!existsSync(root)) {
         throw new Error(`root path does not exist: ${root}`);
     }
-    if (extensionPath && !existsSync(extensionPath)) {
-        throw new Error(`extension path does not exist: ${extensionPath}`);
+    const allExtensionPaths = getExtensionPaths(extensionPath, extensionPaths);
+    for (const extensionPath of allExtensionPaths) {
+        if (!existsSync(extensionPath)) {
+            throw new Error(`extension path does not exist: ${extensionPath}`);
+        }
     }
     if (!serverStaticPath) {
         serverStaticPath = resolveServerStaticPath(root);
     }
     if (pathPrefix === 'auto') {
+        if (allExtensionPaths.length === 0) {
+            throw new Error(`extension path is required when path prefix is auto`);
+        }
+        const [extensionPath] = allExtensionPaths;
         const extensionJson = await readExtensionManifest(Path.join(extensionPath, 'extension.json'));
         const { id } = extensionJson;
         const [author, name] = id.split('.');
@@ -536,7 +587,7 @@ export const exportStatic = async ({ root, pathPrefix, extensionPath, testPath,
     });
     console.timeEnd('applyOverrides');
     await updateExtensionsJson({ root, commitHash, pathPrefix, extraExtensions: [] });
-    if (extensionPath) {
+    for (const extensionPath of allExtensionPaths) {
         console.time('addExtension');
         await addExtension({
             extensionPath,

package/src/parts/GetAppWindowOptions/GetAppWindowOptions.js

@@ -1,6 +1,34 @@
 import * as GetBrowserWindowOptions from '../GetBrowserWindowOptions/GetBrowserWindowOptions.js';
+import * as ExtensionManagementColorTheme from '../ExtensionManagement/ExtensionManagementColorTheme.js';
 import * as Platform from '../Platform/Platform.js';
-export const getAppWindowOptions = ({ preferences, screenWidth, screenHeight, preloadUrl }) => {
+const fallbackBackground = '#1e2324';
+const fallbackSymbolColor = '#74b1be';
+const getColor = (colors, keys, fallback) => {
+    for (const key of keys) {
+        if (colors[key]) {
+            return colors[key];
+        }
+    }
+    return fallback;
+};
+const getColorThemeJson = async (preferences) => {
+    const colorThemeId = preferences['workbench.colorTheme'];
+    if (!colorThemeId) {
+        return {};
+    }
+    try {
+        return await ExtensionManagementColorTheme.getColorThemeJson(colorThemeId);
+    }
+    catch {
+        return {};
+    }
+};
+export const getAppWindowOptions = async ({ preferences, screenWidth, screenHeight, preloadUrl }) => {
+    const colorThemeJson = await getColorThemeJson(preferences);
+    const colors = colorThemeJson.colors && typeof colorThemeJson.colors === 'object' ? colorThemeJson.colors : {};
+    const background = getColor(colors, ['MainBackground'], fallbackBackground);
+    const titleBarBackground = getColor(colors, ['TitleBarActiveBackground', 'TitleBarBackground', 'MainBackground'], fallbackBackground);
+    const titleBarSymbolColor = getColor(colors, ['TitleBarForegroundActive', 'TitleBarForeground', 'TitleBarColor', 'TitleBarColorInactive'], fallbackSymbolColor);
     const titleBarPreference = preferences['window.titleBarStyle'];
     const frame = titleBarPreference !== 'custom';
     const titleBarStyle = titleBarPreference === 'custom' ? 'hidden' : undefined;
@@ -9,8 +37,8 @@ export const getAppWindowOptions = ({ preferences, screenWidth, screenHeight, pr
     const windowControlsOverlayPreference = (Platform.isWindows || Platform.isMacOs || Platform.isLinux) && preferences['window.controlsOverlay.enabled'];
     const titleBarOverlay = windowControlsOverlayPreference
         ? {
-            color: '#1e2324',
-            symbolColor: '#74b1be',
+            color: titleBarBackground,
+            symbolColor: titleBarSymbolColor,
             height: 29,
         }
         : undefined;
@@ -19,7 +47,7 @@ export const getAppWindowOptions = ({ preferences, screenWidth, screenHeight, pr
         x: screenWidth - 800,
         width: 800,
         height: screenHeight,
-        background: '#1e2324',
+        background,
         titleBarStyle,
         frame,
         titleBarOverlay,

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.85.1';
-export const commit = '6f0f9b3';
-export const date = '2026-07-08T07:37:58.000Z';
+export const version = '0.85.3';
+export const commit = 'bbc1fd1';
+export const date = '2026-07-09T05:12:11.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
 import * as Root from '../Root/Root.js';
 export const getPreloadUrl = () => {
-    return join(Root.root, 'static', '6f0f9b3', 'packages', 'preload', 'dist', 'index.js');
+    return join(Root.root, 'static', 'bbc1fd1', 'packages', 'preload', 'dist', 'index.js');
 };