@lvce-editor/status-bar-worker 1.1.0 → 1.3.0

package/dist/statusBarWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -378,32 +421,32 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set = (id, fn) => {
+const set$2 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get = id => {
+const get$3 = id => {
   return callbacks[id];
 };
 const remove = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
   } = Promise.withResolvers();
-  set(id, resolve);
+  set$2(id, resolve);
   return {
     id,
     promise
   };
 };
-const create$2 = (method, params) => {
+const create$2$1 = (method, params) => {
   const {
     id,
     promise
@@ -562,7 +605,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$3(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -612,7 +655,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
     jsonrpc: Two,
     id,
@@ -623,7 +666,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
 const create$5 = (message, result) => {
   return {
@@ -729,7 +772,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
-  } = create$2(method, params);
+  } = create$2$1(method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -742,7 +785,7 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
@@ -781,7 +824,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
@@ -822,7 +865,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -834,10 +877,434 @@ const create = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create
+  create: create$3
 };
 
-const commandMap = {};
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$2 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    get(uid) {
+      return states[uid];
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        oldState,
+        newState
+      };
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseInt(key);
+      });
+    },
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          oldState,
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latest = states[uid];
+        states[uid] = {
+          oldState: latest.oldState,
+          newState: newerState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        newState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
+};
+
+const {
+  get: get$2,
+  set: set$1,
+  wrapCommand} = create$2();
+
+const create$1 = uid => {
+  const state = {
+    statusBarItemsLeft: [],
+    statusBarItemsRight: [],
+    uid
+  };
+  set$1(uid, state, state);
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState.statusBarItemsLeft === newState.statusBarItemsLeft && oldState.statusBarItemsRight === newState.statusBarItemsRight;
+};
+
+const RenderItems = 4;
+
+const modules = [isEqual];
+const numbers = [RenderItems];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    newState,
+    oldState
+  } = get$2(uid);
+  const result = diff(oldState, newState);
+  return result;
+};
+
+const handleClick = (state, name) => {
+  // TODO
+  // sendExtensionWorker([/* statusBarItemHandleClick */ 7657, /* name */ name])
+  return state;
+};
+
+const getIndex = (items, item) => {
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].name === item.name) {
+      return i;
+    }
+  }
+  return -1;
+};
+const updateArray = (items, newItem) => {
+  const index = getIndex(items, newItem);
+  const before = items.slice(0, index);
+  const after = items.slice(index + 1);
+  return [...before, newItem, ...after];
+};
+
+const itemLeftUpdate = (state, newItem) => {
+  return {
+    ...state,
+    statusBarItemsLeft: updateArray([...state.statusBarItemsLeft], newItem)
+  };
+};
+
+const itemRightCreate = (state, newItem) => {
+  const {
+    statusBarItemsRight
+  } = state;
+  const newStatusBarItemsRight = [...statusBarItemsRight, newItem];
+  return {
+    ...state,
+    statusBarItemsRight: newStatusBarItemsRight
+  };
+};
+
+const itemRightUpdate = (state, newItem) => {
+  const {
+    statusBarItemsRight
+  } = state;
+  const newStatusBarItemsRight = updateArray([...statusBarItemsRight], newItem);
+  return {
+    ...state,
+    statusBarItemsRight: newStatusBarItemsRight
+  };
+};
+
+const OnStatusBarItem = 'onStatusBarItem';
+
+const GetStatusBarItems = 'ExtensionHost.getStatusBarItems';
+
+const Button = 'button';
+
+const Div = 4;
+const Text = 12;
+
+const ExtensionHostWorker = 44;
+const RendererWorker = 1;
+
+const SetDom2 = 'Viewlet.setDom2';
+
+const rpcs = Object.create(null);
+const set = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$1 = id => {
+  return rpcs[id];
+};
+
+const create = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$1(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+
+const {
+  invoke: invoke$1} = create(ExtensionHostWorker);
+
+const {
+  invoke} = create(RendererWorker);
+const activateByEvent$1 = event => {
+  return invoke('ExtensionHostManagement.activateByEvent', event);
+};
+const getPreference = async key => {
+  return await invoke('Preferences.get', key);
+};
+
+const activateByEvent = event => {
+  return activateByEvent$1(event);
+};
+
+const executeProviders = async ({
+  combineResults,
+  event,
+  method,
+  noProviderFoundMessage = 'No provider found',
+  noProviderFoundResult,
+  params
+}) => {
+  await activateByEvent(event);
+  // @ts-ignore
+  const result = await invoke$1(method, ...params);
+  return result;
+};
+
+const combineResults = results => {
+  return results.flat();
+};
+const getStatusBarItems$1 = () => {
+  return executeProviders({
+    combineResults,
+    event: OnStatusBarItem,
+    method: GetStatusBarItems,
+    noProviderFoundMessage: 'No status bar item provider found',
+    noProviderFoundResult: [],
+    params: []
+  });
+};
+
+const toUiStatusBarItem = extensionHostStatusBarItem => {
+  return {
+    command: extensionHostStatusBarItem.command || '',
+    icon: extensionHostStatusBarItem.icon || '',
+    name: extensionHostStatusBarItem.id || '',
+    text: extensionHostStatusBarItem.text || '',
+    tooltip: extensionHostStatusBarItem.tooltip || ''
+  };
+};
+const toUiStatusBarItems = statusBarItems => {
+  if (!statusBarItems) {
+    return [];
+  }
+  return statusBarItems.map(toUiStatusBarItem);
+};
+const getStatusBarItems = async showItems => {
+  if (!showItems) {
+    return [];
+  }
+  await activateByEvent('onSourceControl');
+  const extensionStatusBarItems = await getStatusBarItems$1();
+  const uiStatusBarItems = toUiStatusBarItems(extensionStatusBarItems);
+  return uiStatusBarItems;
+};
+
+const get = async key => {
+  return getPreference(key);
+};
+
+const itemsVisible = async () => {
+  const statusBarItemsPreference = (await get('statusBar.itemsVisible')) ?? false;
+  return statusBarItemsPreference;
+};
+
+const loadContent = async state => {
+  const statusBarItemsPreference = await itemsVisible();
+  const statusBarItems = await getStatusBarItems(statusBarItemsPreference);
+  return {
+    ...state,
+    statusBarItemsLeft: [...statusBarItems]
+  };
+};
+
+const StatusBarItem = 'StatusBarItem';
+const StatusBarItemsLeft = 'StatusBarItemsLeft';
+const StatusBarItemsRight = 'StatusBarItemsRight';
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const getStatusBarItemVirtualDom = statusBarItem => {
+  const {
+    tooltip
+  } = statusBarItem;
+  return [{
+    childCount: 1,
+    className: StatusBarItem,
+    role: Button,
+    tabIndex: -1,
+    title: tooltip,
+    type: Div
+  }, text(statusBarItem.text)];
+};
+
+const getStatusBarItemsVirtualDom = (items, className) => {
+  return [{
+    childCount: items.length,
+    className,
+    type: Div
+  }, ...items.flatMap(getStatusBarItemVirtualDom)];
+};
+
+const getStatusBarVirtualDom = (statusBarItemsLeft, statusBarItemsRight) => {
+  const dom = [];
+  if (statusBarItemsLeft.length > 0) {
+    dom.push(...getStatusBarItemsVirtualDom(statusBarItemsLeft, StatusBarItemsLeft));
+  }
+  if (statusBarItemsRight.length > 0) {
+    dom.push(...getStatusBarItemsVirtualDom(statusBarItemsRight, StatusBarItemsRight));
+  }
+  return dom;
+};
+
+const renderItems = (oldState, newState) => {
+  const {
+    statusBarItemsLeft,
+    statusBarItemsRight,
+    uid
+  } = newState;
+  const dom = getStatusBarVirtualDom(statusBarItemsLeft, statusBarItemsRight);
+  return [SetDom2, uid, dom];
+};
+
+const getRenderer = diffType => {
+  switch (diffType) {
+    case RenderItems:
+      return renderItems;
+    default:
+      throw new Error('unknown renderer');
+  }
+};
+
+const applyRender = (oldState, newState, diffResult) => {
+  const commands = [];
+  for (const item of diffResult) {
+    const fn = getRenderer(item);
+    const result = fn(oldState, newState);
+    if (result.length > 0) {
+      commands.push(result);
+    }
+  }
+  return commands;
+};
+
+const render2 = (uid, diffResult) => {
+  const {
+    newState,
+    oldState
+  } = get$2(uid);
+  set$1(uid, newState, newState);
+  const commands = applyRender(oldState, newState, diffResult);
+  return commands;
+};
+
+const saveState = uid => {
+  number(uid);
+  const value = get$2(uid);
+  const {
+    newState
+  } = value;
+  const {
+    statusBarItemsLeft,
+    statusBarItemsRight
+  } = newState;
+  return {
+    itemsLeft: statusBarItemsLeft,
+    itemsRight: statusBarItemsRight
+  };
+};
+
+const commandMap = {
+  'StatusBar.create': create$1,
+  'StatusBar.diff2': diff2,
+  'StatusBar.handleClick': wrapCommand(handleClick),
+  'StatusBar.itemLeftUpdate': wrapCommand(itemLeftUpdate),
+  'StatusBar.itemRightCreate': wrapCommand(itemRightCreate),
+  'StatusBar.itemRightUpdate': wrapCommand(itemRightUpdate),
+  'StatusBar.loadContent': wrapCommand(loadContent),
+  'StatusBar.render2': render2,
+  'StatusBar.saveState': saveState,
+  'StatusBar.terminate': terminate
+};
 
 const listen = async () => {
   await WebWorkerRpcClient.create({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/status-bar-worker",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Status Bar Worker",
   "repository": {
     "type": "git",
@@ -9,5 +9,8 @@
   "license": "MIT",
   "author": "Lvce Editor",
   "type": "module",
-  "main": "dist/statusBarWorkerMain.js"
+  "main": "dist/statusBarWorkerMain.js",
+  "dependencies": {
+    "@lvce-editor/virtual-dom-worker": "^4.0.0"
+  }
 }