@lvce-editor/extension-management-worker 1.7.0 → 1.9.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();
@@ -1363,6 +1372,7 @@ const getJson = async url => {
   }
 };
 
+const NewLine = '\n';
 const Slash = '/';
 
 const interExtensionId = path => {
@@ -1404,7 +1414,7 @@ let state = {
   disabledIds: [],
   platform: 0
 };
-const set = newState => {
+const set$1 = newState => {
   state = newState;
 };
 const update = newState => {
@@ -1414,19 +1424,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 +1448,7 @@ const disableExtension = async (id, isTest) => {
 };
 
 const enableExtension = async (id, isTest) => {
-  const oldState = get();
+  const oldState = get$1();
   const {
     platform
   } = oldState;
@@ -1463,19 +1473,245 @@ 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);
+};
+
+const join = (pathSeparator, ...parts) => {
+  return parts.join(pathSeparator);
+};
+
+const getColorThemeUri = (extensions, colorThemeId) => {
+  for (const extension of extensions) {
+    if (!extension.colorThemes) {
+      continue;
+    }
+    for (const colorTheme of extension.colorThemes) {
+      if (colorTheme.id !== colorThemeId) {
+        continue;
+      }
+      const absolutePath = join('/', extension.uri, colorTheme.path);
+      return absolutePath;
+    }
+  }
+  return '';
+};
+
 const getAllExtensions = async () => {
-  const state = get();
+  const state = get$1();
   if (state.platform === Web) {
     return [];
   }
   return invoke('ExtensionManagement.getAllExtensions');
 };
 
+const getColorThemeJson$2 = async colorThemeId => {
+  const extensions = await getAllExtensions();
+  const colorThemeUri = getColorThemeUri(extensions, colorThemeId);
+  if (!colorThemeUri) {
+    return {};
+  }
+  const json = await readJson(colorThemeUri);
+  return json;
+};
+
+const assetDir = '';
+
+const getColorThemeUrlWeb = colorThemeId => {
+  return `${assetDir}/extensions/builtin.theme-${colorThemeId}/color-theme.json`;
+};
+const getColorThemeJson$1 = colorThemeId => {
+  const url = getColorThemeUrlWeb(colorThemeId);
+  // TODO handle error ?
+  return getJson(url);
+};
+
+const getColorThemeJson = (colorThemeId, platform) => {
+  if (platform === Web) {
+    return getColorThemeJson$1(colorThemeId);
+  }
+  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 || [];
+};
+const getColorThemeId = colorTheme => {
+  return colorTheme.id;
+};
+
+// TODO should send names to renderer worker or names with ids?
+const getColorThemeNamesFromExtensions = async extensions => {
+  const colorThemes = extensions.flatMap(getExtensionColorThemeNames);
+  const colorThemeNames = colorThemes.map(getColorThemeId);
+  return colorThemeNames;
+};
+
+const getColorThemeNames = async () => {
+  const extensions = await getAllExtensions();
+  const colorThemeNames = getColorThemeNamesFromExtensions(extensions);
+  return colorThemeNames;
+};
+
 const getExtension = async id => {
   const allExtensions = await getAllExtensions();
   for (const extension of allExtensions) {
@@ -1498,7 +1734,7 @@ const emptyStatus = {
   status: None
 };
 const getRuntimeStatus = extensionId => {
-  return get$1(extensionId) || emptyStatus;
+  return get$2(extensionId) || emptyStatus;
 };
 
 const commandMapRef = {};
@@ -1514,7 +1750,7 @@ const importExtension = async (extensionId, absolutePath, activationEvent) => {
   try {
     string(absolutePath);
     const startTime = performance.now();
-    set$1({
+    set$2({
       activationEndTime: 0,
       activationEvent: activationEvent,
       activationStartTime: performance.now(),
@@ -1555,7 +1791,7 @@ const initializeExtensionHostWorker = async () => {
       await sendMessagePortToExtensionHostWorker(port, 0);
     }
   });
-  set$5(rpc);
+  set$6(rpc);
 };
 
 const initializeFileSystemWorker = async () => {
@@ -1565,7 +1801,7 @@ const initializeFileSystemWorker = async () => {
       await sendMessagePortToFileSystemWorker(port, 0);
     }
   });
-  set$4(rpc);
+  set$5(rpc);
 };
 
 const getRpc = async platform => {
@@ -1591,7 +1827,7 @@ const getRpc = async platform => {
 const initializeSharedProcess = async platform => {
   const rpc = await getRpc(platform);
   if (rpc) {
-    set$2(rpc);
+    set$3(rpc);
   }
 };
 
@@ -1606,6 +1842,50 @@ const installExtension = async () => {
   // TODO
 };
 
+const getLanguagesFromExtension = extension => {
+  // TODO what if extension is null? should not crash process, handle error gracefully
+  // TODO what if extension languages is not of type array?
+  // TODO what if language is null?
+  if (!extension) {
+    return [];
+  }
+  if (!extension.languages) {
+    return [];
+  }
+  const extensionPath = extension.path;
+  const getLanguageFromExtension = language => {
+    if (language.tokenize) {
+      if (typeof language.tokenize !== 'string') {
+        console.warn(`[info] ${language.id}: language.tokenize must be of type string but was of type ${typeof language.tokenize}`);
+        return {
+          ...language,
+          extensionPath,
+          tokenize: ''
+        };
+      }
+      const relativePath = `${extensionPath}/${language.tokenize}`;
+      const absolutePath = relativePath ;
+      return {
+        ...language,
+        extensionPath,
+        tokenize: absolutePath
+      };
+    }
+    return language;
+  };
+  return extension.languages.map(getLanguageFromExtension);
+};
+
+const getLanguages = async () => {
+  try {
+    const extensions = await getAllExtensions();
+    const languages = extensions.flatMap(getLanguagesFromExtension);
+    return languages;
+  } catch (error) {
+    throw new VError(error, 'Failed to load languages');
+  }
+};
+
 const uninstallExtension = async () => {
   // TODO
 };
@@ -1616,12 +1896,17 @@ const commandMap = {
   'Extensions.disable': disableExtension,
   'Extensions.enable': enableExtension,
   'Extensions.getAllExtensions': getAllExtensions,
+  'Extensions.getColorThemeCssFromJson': getColorThemeCss,
+  'Extensions.getColorThemeJson': getColorThemeJson,
+  'Extensions.getColorThemeNames': getColorThemeNames,
   'Extensions.getExtension': getExtension,
+  'Extensions.getLanguages': getLanguages,
   'Extensions.getRuntimeStatus': getRuntimeStatus,
   'Extensions.handleMessagePort': handleMessagePort,
   'Extensions.importExtension': importExtension,
   'Extensions.initialize': initialize,
   'Extensions.install': installExtension,
+  'Extensions.invalidateExtensionsCache': invalidateExtensionsCache,
   'Extensions.uninstall': uninstallExtension
 };
 
@@ -1630,7 +1915,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.7.0",
+  "version": "1.9.0",
   "description": "Webworker for the Extension Management functionality in Lvce Editor.",
   "keywords": [
     "web-worker"