@lvce-editor/extension-management-worker 1.8.0 → 1.10.0

package/dist/extensionManagementWorkerMain.js

@@ -14,9 +14,9 @@ const getCombinedMessage = (error, message) => {
   }
   return stringifiedError;
 };
-const NewLine$2 = '\n';
+const NewLine$3 = '\n';
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
+  return string.indexOf(NewLine$3, startIndex);
 };
 const mergeStacks = (parent, child) => {
   if (!child) {
@@ -90,6 +90,12 @@ const getType = value => {
       return Unknown;
   }
 };
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
 const string = value => {
   const type = getType(value);
   if (type !== String) {
@@ -170,9 +176,9 @@ class Ipc extends EventTarget {
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
 const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
+const NewLine$2 = '\n';
 const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+  return lines.join(NewLine$2);
 };
 const RE_AT = /^\s+at/;
 const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
@@ -199,7 +205,7 @@ const getDetails = lines => {
   };
 };
 const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
+  return lines.split(NewLine$2);
 };
 const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
 const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
@@ -578,10 +584,10 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$7 = (id, fn) => {
+const set$8 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$3 = id => {
+const get$4 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -597,7 +603,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$7(id, resolve);
+  set$8(id, resolve);
   return {
     id,
     promise
@@ -625,7 +631,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine = '\n';
+const NewLine$1 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -671,10 +677,10 @@ const constructError = (message, type, name) => {
   return new ErrorConstructor(message);
 };
 const joinLines = lines => {
-  return lines.join(NewLine);
+  return lines.join(NewLine$1);
 };
 const splitLines = lines => {
-  return lines.split(NewLine);
+  return lines.split(NewLine$1);
 };
 const getCurrentStack = () => {
   const stackLinesToSkip = 3;
@@ -682,12 +688,12 @@ const getCurrentStack = () => {
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+  return string.indexOf(NewLine$1, startIndex);
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
+    parentStack = error.message + NewLine$1 + parentStack;
   }
   return parentStack;
 };
@@ -697,21 +703,21 @@ const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
     if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
+      error.stack = error.stack + NewLine$1 + currentStack;
     }
     return error;
   }
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
+    restoredError.stack = parentStack + NewLine$1 + currentStack;
     return restoredError;
   }
   if (error && error.message) {
     const restoredError = constructError(error.message, error.type, error.name);
     if (error.data) {
       if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$1 + error.data.stack + NewLine$1 + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
@@ -758,14 +764,14 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-const warn = (...args) => {
+const warn$1 = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$3(id);
+  const fn = get$4(id);
   if (!fn) {
     console.log(response);
-    warn(`callback ${id} may already be disposed`);
+    warn$1(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
@@ -1133,45 +1139,45 @@ const RendererWorker = 1;
 const SharedProcess = 1;
 
 const rpcs = Object.create(null);
-const set$6 = (id, rpc) => {
+const set$7 = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$2 = id => {
+const get$3 = id => {
   return rpcs[id];
 };
 
 const create$1 = rpcId => {
   return {
     async dispose() {
-      const rpc = get$2(rpcId);
+      const rpc = get$3(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$2(rpcId);
+      const rpc = get$3(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$2(rpcId);
+      const rpc = get$3(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$6(rpcId, rpc);
+      set$7(rpcId, rpc);
     }
   };
 };
 
 const {
   invoke: invoke$3,
-  set: set$5
+  set: set$6
 } = create$1(ExtensionHostWorker);
 
 const {
   invoke: invoke$2,
-  set: set$4
+  set: set$5
 } = create$1(FileSystemWorker);
 const readFile = async uri => {
   return invoke$2('FileSystem.readFile', uri);
@@ -1187,7 +1193,7 @@ const exists = async uri => {
 const {
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$3
+  set: set$4
 } = create$1(RendererWorker);
 const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
@@ -1206,7 +1212,7 @@ const sendMessagePortToSharedProcess = async port => {
 
 const {
   invoke,
-  set: set$2
+  set: set$3
 } = create$1(SharedProcess);
 
 const create = () => {
@@ -1252,10 +1258,10 @@ const isImportError = error => {
 };
 
 const states = Object.create(null);
-const set$1 = status => {
+const set$2 = status => {
   states[status.id] = status;
 };
-const get$1 = extensionId => {
+const get$2 = extensionId => {
   return states[extensionId];
 };
 const update$1 = (id, update) => {
@@ -1314,6 +1320,9 @@ const activate = async (extensionId, extension) => {
   await invoke$3('ExtensionHost.activateExtension3', extensionId, extension);
 };
 const activateExtension2 = async (extensionId, extension, absolutePath) => {
+  string(extensionId);
+  object(extension);
+  string(absolutePath);
   const token = create();
   try {
     const startTime = performance.now();
@@ -1344,6 +1353,50 @@ const activateExtension2 = async (extensionId, extension, absolutePath) => {
   }
 };
 
+const importExtension = async (extensionId, absolutePath, activationEvent) => {
+  try {
+    string(absolutePath);
+    const startTime = performance.now();
+    set$2({
+      activationEndTime: 0,
+      activationEvent: activationEvent,
+      activationStartTime: performance.now(),
+      activationTime: 0,
+      id: extensionId,
+      importEndTime: 0,
+      importStartTime: startTime,
+      importTime: 0,
+      status: Importing
+    });
+    try {
+      await invoke$3('ExtensionHost.importExtension2', extensionId, absolutePath);
+      const endTime = performance.now();
+      const time = endTime - startTime;
+      update$1(extensionId, {
+        importEndTime: endTime,
+        importTime: time
+      });
+    } catch (error) {
+      update$1(extensionId, {
+        status: Error$1 // TODO maybe store error also in runtime status state
+      });
+      if (isImportError(error)) {
+        const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
+        throw new Error(actualErrorMessage);
+      }
+      throw error;
+    }
+  } catch (error) {
+    throw new VError(error, `Failed to import extension ${extensionId}`);
+  }
+};
+
+const activateExtension3 = async (extension, absolutePath, activationEvent) => {
+  const extensionId = extension.id;
+  await importExtension(extensionId, absolutePath, activationEvent);
+  await activateExtension2(extensionId, extension, absolutePath);
+};
+
 const cache = Object.create(null);
 const id = 1;
 const clear = () => {
@@ -1363,6 +1416,7 @@ const getJson = async url => {
   }
 };
 
+const NewLine = '\n';
 const Slash = '/';
 
 const interExtensionId = path => {
@@ -1404,7 +1458,7 @@ let state = {
   disabledIds: [],
   platform: 0
 };
-const set = newState => {
+const set$1 = newState => {
   state = newState;
 };
 const update = newState => {
@@ -1414,19 +1468,19 @@ const update = newState => {
   };
   state = fullNewState;
 };
-const get = () => {
+const get$1 = () => {
   return state;
 };
 
 const disableExtension = async (id, isTest) => {
-  const oldState = get();
+  const oldState = get$1();
   try {
     if (isTest) {
       const newState = {
         ...oldState,
         disabledIds: [...oldState.disabledIds, id]
       };
-      set(newState);
+      set$1(newState);
     } else {
       await invoke('ExtensionManagement.disable', id);
     }
@@ -1438,7 +1492,7 @@ const disableExtension = async (id, isTest) => {
 };
 
 const enableExtension = async (id, isTest) => {
-  const oldState = get();
+  const oldState = get$1();
   const {
     platform
   } = oldState;
@@ -1463,11 +1517,151 @@ const enableExtension = async (id, isTest) => {
       ...oldState,
       disabledIds: oldState.disabledIds.filter(existing => existing !== id)
     };
-    set(newState);
+    set$1(newState);
   }
   return undefined;
 };
 
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+const warn = (...args) => {
+  console.warn(...args);
+};
+
+const transparent = (color, factor) => {
+  return color;
+};
+const toColorRule = ([key, value]) => {
+  return `  --${key}: ${value};`;
+};
+const toTokenColorRule = tokenColor => {
+  return `.${tokenColor.name} { color: ${tokenColor.foreground} }`;
+};
+const addFallbackColors = colors => {
+  const newColors = {
+    ...colors
+  };
+  if (!newColors.ActivityBarInactiveForeground) {
+    // TODO don't assign, avoid mutation
+    newColors.ActivityBarInactiveForeground = transparent(newColors.ActivityBarForeground);
+  }
+  newColors.CssVariableName ||= colors.VariableName;
+  return newColors;
+};
+const createColorThemeFromJson = (colorThemeId, colorThemeJson) => {
+  if (!colorThemeJson) {
+    warn(`color theme json for "${colorThemeId}" is empty: "${colorThemeJson}"`);
+    return '';
+  }
+  if (typeof colorThemeJson !== 'object') {
+    warn(`color theme json for "${colorThemeId}" cannot be converted to css: "${colorThemeJson}"`);
+    return '';
+  }
+  if (Array.isArray(colorThemeJson)) {
+    warn(`color theme json for "${colorThemeId}" cannot be converted to css, it must be of type object but was of type array`);
+    return '';
+  }
+  const {
+    colors
+  } = colorThemeJson;
+  if (!colors) {
+    return '';
+  }
+  const newColors = addFallbackColors(colors);
+  const colorRules = Object.entries(newColors).map(toColorRule);
+  const tokenColors = colorThemeJson.tokenColors || [];
+  const tokenColorRules = tokenColors.map(toTokenColorRule);
+  const extraRules = [];
+  if (colors.ContrastBorder) {
+    extraRules.push(`#ActivityBar, #SideBar {
+  border-left: 1px solid var(--ContrastBorder);
+}`, `#Panel {
+  border-top: 1px solid var(--ContrastBorder);
+}`, `#StatusBar {
+  border-top: 1px solid var(--ContrastBorder);
+}`, `.ActivityBarItemBadge {
+  border: 1px solid var(--ContrastBorder);
+}`, `#QuickPick {
+  border: 1px solid var(--ContrastBorder);
+}`);
+  }
+  const colorThemeCss = `:root {\n${colorRules.join(NewLine)}\n}\n\n${tokenColorRules.join(NewLine)}\n\n${extraRules.join(NewLine)}`;
+  return colorThemeCss;
+};
+
+// for (let i = 0; i < 10000; i++) {
+//   createColorThemeFromJson({
+//     type: 'dark',
+//     colors: {
+//       ActivityBarBackground: 'rgb(40, 46, 47)',
+//       ActivityBarForeground: '#878f8c',
+//       ActivityBarActiveBackground: '#1f2727',
+
+//       EditorBackGround: '#1e2324',
+//       EditorScrollBarBackground: 'rgba(57, 71, 71, 0.6)',
+//       EditorCursorBackground: '#a8df5a',
+
+//       ListActiveSelectionBackground: '#515f59',
+//       ListActiveSelectionForeground: '#ffffff',
+//       ListHoverBackground: '#405c5033',
+//       ListHoverForeground: '#e0e0e0',
+//       ListInactiveSelectionBackground: '#3b474280',
+
+//       MainBackground: '#1e2324',
+
+//       PanelBackground: '#1b2020',
+//       PanelBorderTopColor: 'rgba(128, 128, 128, 0.35)',
+
+//       SideBarBackground: '#1b2020',
+
+//       StatusBarBackground: 'rgb(40, 46, 47)',
+//       StatusBarBorderTopColor: '#222222',
+
+//       TabActiveBackground: '#24292a',
+//       TabInactiveBackground: '#282e2f',
+
+//       TitleBarBackground: 'rgb(40, 46, 47)',
+//       TitleBarBorderBottomColor: '#222',
+//       TitleBarColor: '#cccccc',
+//       TitleBarColorInactive: 'rgba(204, 204, 204, 0.6)',
+//     },
+//   }) //?.
+// }
+
+const get = colorThemeId => {
+  return '';
+};
+const set = (colorThemeId, data) => {
+  //  noop
+};
+
+const GetColorThemeCssCachedNoop = {
+  __proto__: null,
+  get,
+  set
+};
+
+// TODO make storage configurable via settings as localstorage or indexeddb
+// also allow disabling caching via settings
+// then measure which option could be fastest
+
+const getCacheFn = config => {
+  switch (config) {
+    default:
+      return GetColorThemeCssCachedNoop;
+  }
+};
+const getColorThemeCssCached = async (colorThemeId, platform, getData) => {
+  const config = '';
+  const module = getCacheFn(config);
+  const cachedData = module.get(colorThemeId);
+  if (cachedData) {
+    return cachedData;
+  }
+  const newData = await getData(colorThemeId, platform);
+  module.set(colorThemeId, newData);
+  return newData;
+};
+
 const readJson = url => {
   return invoke$1('FileSystem.readJson', url);
 };
@@ -1493,7 +1687,7 @@ const getColorThemeUri = (extensions, colorThemeId) => {
 };
 
 const getAllExtensions = async () => {
-  const state = get();
+  const state = get$1();
   if (state.platform === Web) {
     return [];
   }
@@ -1528,6 +1722,20 @@ const getColorThemeJson = (colorThemeId, platform) => {
   return getColorThemeJson$2(colorThemeId);
 };
 
+const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
+  const colorThemeCss = createColorThemeFromJson(/* colorThemeId */colorThemeId, /* colorThemeJson */colorThemeJson);
+  return colorThemeCss;
+  // TODO generate color theme from jsonc
+};
+const getColorThemeCssNew = async (colorThemeId, platform) => {
+  const colorThemeJson = await getColorThemeJson(colorThemeId, platform);
+  const colorThemeCss = await getColorThemeCssFromJson(colorThemeId, colorThemeJson);
+  return colorThemeCss;
+};
+const getColorThemeCss = (colorThemeId, platform) => {
+  return getColorThemeCssCached(colorThemeId, platform, getColorThemeCssNew);
+};
+
 const getExtensionColorThemeNames = extension => {
   return extension.colorThemes || [];
 };
@@ -1570,7 +1778,7 @@ const emptyStatus = {
   status: None
 };
 const getRuntimeStatus = extensionId => {
-  return get$1(extensionId) || emptyStatus;
+  return get$2(extensionId) || emptyStatus;
 };
 
 const commandMapRef = {};
@@ -1582,44 +1790,6 @@ const handleMessagePort = async port => {
   });
 };
 
-const importExtension = async (extensionId, absolutePath, activationEvent) => {
-  try {
-    string(absolutePath);
-    const startTime = performance.now();
-    set$1({
-      activationEndTime: 0,
-      activationEvent: activationEvent,
-      activationStartTime: performance.now(),
-      activationTime: 0,
-      id: extensionId,
-      importEndTime: 0,
-      importStartTime: startTime,
-      importTime: 0,
-      status: Importing
-    });
-    try {
-      await invoke$3('ExtneionHost.importExtension2', extensionId, absolutePath);
-      const endTime = performance.now();
-      const time = endTime - startTime;
-      update$1(extensionId, {
-        importEndTime: endTime,
-        importTime: time
-      });
-    } catch (error) {
-      update$1(extensionId, {
-        status: Error$1 // TODO maybe store error also in runtime status state
-      });
-      if (isImportError(error)) {
-        const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
-        throw new Error(actualErrorMessage);
-      }
-      throw error;
-    }
-  } catch (error) {
-    throw new VError(error, `Failed to import extension ${extensionId}`);
-  }
-};
-
 const initializeExtensionHostWorker = async () => {
   const rpc = await TransferMessagePortRpcParent.create({
     commandMap: commandMapRef,
@@ -1627,7 +1797,7 @@ const initializeExtensionHostWorker = async () => {
       await sendMessagePortToExtensionHostWorker(port, 0);
     }
   });
-  set$5(rpc);
+  set$6(rpc);
 };
 
 const initializeFileSystemWorker = async () => {
@@ -1637,7 +1807,7 @@ const initializeFileSystemWorker = async () => {
       await sendMessagePortToFileSystemWorker(port, 0);
     }
   });
-  set$4(rpc);
+  set$5(rpc);
 };
 
 const getRpc = async platform => {
@@ -1663,7 +1833,7 @@ const getRpc = async platform => {
 const initializeSharedProcess = async platform => {
   const rpc = await getRpc(platform);
   if (rpc) {
-    set$2(rpc);
+    set$3(rpc);
   }
 };
 
@@ -1728,10 +1898,12 @@ const uninstallExtension = async () => {
 
 const commandMap = {
   'Extensions.activate2': activateExtension2,
+  'Extensions.activate3': activateExtension3,
   'Extensions.addWebExtension': addWebExtension,
   'Extensions.disable': disableExtension,
   'Extensions.enable': enableExtension,
   'Extensions.getAllExtensions': getAllExtensions,
+  'Extensions.getColorThemeCssFromJson': getColorThemeCss,
   'Extensions.getColorThemeJson': getColorThemeJson,
   'Extensions.getColorThemeNames': getColorThemeNames,
   'Extensions.getExtension': getExtension,
@@ -1750,7 +1922,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$3(rpc);
+  set$4(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-management-worker",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Webworker for the Extension Management functionality in Lvce Editor.",
   "keywords": [
     "web-worker"