@lvce-editor/source-control-worker 1.0.0 → 1.2.0

package/dist/sourceControlWorkerMain.js

@@ -54,6 +54,47 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'unknown';
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -379,6 +420,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two = '2.0';
 const create$4 = (method, params) => {
@@ -389,10 +524,10 @@ const create$4 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
+const set$2 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get = id => {
+const get$3 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -408,7 +543,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$1(id, resolve);
+  set$2(id, resolve);
   return {
     id,
     promise
@@ -565,7 +700,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`);
@@ -604,7 +739,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1 = (message, error) => {
+const create$1$1 = (message, error) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -615,7 +750,7 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
+  return create$1$1(message, errorProperty);
 };
 const create$5 = (message, result) => {
   return {
@@ -719,10 +854,10 @@ 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) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -752,10 +887,10 @@ 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);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -793,7 +928,27 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create = async ({
+const create$8 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$8
+};
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -805,23 +960,970 @@ const create = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create
+  create: create$1
 };
 
-const terminate = () => {
-  globalThis.close();
+const create = () => {
+  const states = Object.create(null);
+  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 {
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (newState === newerState) {
+          return;
+        }
+        const latest = states[uid];
+        states[uid] = {
+          oldState: latest.oldState,
+          newState: newerState
+        };
+      };
+      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;
+    }
+  };
 };
 
-const commandMap = {
-  'SourceControl.terminate': terminate
+const {
+  get: get$2,
+  set: set$1,
+  wrapCommand
+} = create();
+
+const create2 = (id, uri, x, y, width, height, workspacePath) => {
+  const state = {
+    id,
+    root: '',
+    items: [],
+    x,
+    y,
+    width,
+    height,
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    fileIconCache: Object.create(null),
+    icons: [],
+    finalDeltaY: 0,
+    handleOffset: 0,
+    scrollBarActive: false,
+    scrollBarHeight: 0,
+    merge: [],
+    index: [],
+    untracked: [],
+    workingTree: [],
+    inputValue: '',
+    displayItems: [],
+    buttonIndex: -1,
+    enabledProviderIds: [],
+    isExpanded: true,
+    buttons: [],
+    providerId: '',
+    splitButtonEnabled: false,
+    allGroups: [],
+    gitRoot: '',
+    itemHeight: 20,
+    minimumSliderSize: 20,
+    workspacePath
+  };
+  set$1(id, state, state);
+};
+
+const RenderItems = 4;
+
+const diffType = RenderItems;
+const isEqual = (oldState, newState) => {
+  return oldState.allGroups === newState.allGroups && oldState.displayItems === newState.displayItems && oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.deltaY === newState.deltaY && oldState.buttonIndex === newState.buttonIndex && oldState.buttons === newState.buttons;
+};
+
+const modules = [isEqual];
+const numbers = [diffType];
+
+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 {
+    oldState,
+    newState
+  } = get$2(uid);
+  const result = diff(oldState, newState);
+  return result;
+};
+
+const commandIds = ['acceptInput', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusNone', 'focusPrevious', 'handleClick', 'handleClickAt', 'handleIconThemeChange', 'handleWheel'];
+
+const getCommandIds = () => {
+  return commandIds;
 };
 
 const RendererWorker = 1;
+const ExtensionHostWorker = 44;
+const DebugWorker = 55;
 
 const rpcs = Object.create(null);
 const set = (id, rpc) => {
   rpcs[id] = rpc;
 };
+const get$1 = id => {
+  return rpcs[id];
+};
+
+const invoke$1 = (method, ...params) => {
+  const rpc = get$1(RendererWorker);
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
+};
+const invokeAndTransfer = (method, ...params) => {
+  const rpc = get$1(RendererWorker);
+  // @ts-ignore
+  return rpc.invokeAndTransfer(method, ...params);
+};
+
+const activateByEvent = event => {
+  return invoke$1('ExtensionHostManagement.activateByEvent', event);
+};
+
+const invoke = async (method, ...params) => {
+  const rpc = get$1(ExtensionHostWorker);
+  return rpc.invoke(method, ...params);
+};
+
+const executeProvider = async ({
+  event,
+  method,
+  params
+}) => {
+  await activateByEvent(event);
+  const result = await invoke(method, ...params);
+  return result;
+};
+
+const CommandExecute = 'ExtensionHostCommand.executeCommand';
+const SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
+const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
+
+const executeCommand = (id, ...args) => {
+  return executeProvider({
+    event: `onCommand:${id}`,
+    method: CommandExecute,
+    params: [id, ...args]
+  });
+};
+
+const Directory = 3;
+const DirectoryExpanded = 4;
+const File = 7;
+
+const getFileIcon = ({
+  name
+}) => {
+  return '';
+};
+
+// TODO this should be in FileSystem module
+const pathBaseName = path => {
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+
+const getDisplayItemsGroup = (group, isExpanded) => {
+  const displayItems = [];
+  const {
+    id,
+    label,
+    items
+  } = group;
+  if (!items) {
+    throw new Error('Source control group is missing an items property');
+  }
+  const length = items.length;
+  const type = DirectoryExpanded ;
+  const icon = 'ChevronDown' ;
+  if (length > 0) {
+    displayItems.push({
+      file: '',
+      label,
+      detail: '',
+      posInSet: 1,
+      setSize: 1,
+      icon,
+      decorationIcon: '',
+      decorationIconTitle: '',
+      decorationStrikeThrough: false,
+      type,
+      badgeCount: length,
+      groupId: id
+    });
+  }
+  {
+    for (let i = 0; i < length; i++) {
+      const item = items[i];
+      const {
+        file,
+        icon,
+        iconTitle,
+        strikeThrough
+      } = item;
+      const baseName = pathBaseName(file);
+      const folderName = file.slice(0, -baseName.length - 1);
+      displayItems.push({
+        file,
+        label: baseName,
+        detail: folderName,
+        posInSet: i + 1,
+        setSize: length,
+        icon: getFileIcon({
+          name: file
+        }),
+        decorationIcon: icon,
+        decorationIconTitle: iconTitle,
+        decorationStrikeThrough: strikeThrough,
+        type: File,
+        badgeCount: 0,
+        groupId: id
+      });
+    }
+  }
+  return displayItems;
+};
+const getDisplayItems = (allGroups, isExpanded) => {
+  const displayItems = [];
+  for (const group of allGroups) {
+    const groupDisplayItems = getDisplayItemsGroup(group);
+    displayItems.push(...groupDisplayItems);
+  }
+  return displayItems;
+};
+
+const getFinalDeltaY = (height, itemHeight, itemsLength) => {
+  const contentHeight = itemsLength * itemHeight;
+  const finalDeltaY = Math.max(contentHeight - height, 0);
+  return finalDeltaY;
+};
+
+const getListHeight = (itemsLength, itemHeight, maxHeight) => {
+  number(itemsLength);
+  number(itemHeight);
+  number(maxHeight);
+  if (itemsLength === 0) {
+    return itemHeight;
+  }
+  const totalHeight = itemsLength * itemHeight;
+  return Math.min(totalHeight, maxHeight);
+};
+
+// TODO optimize this function to return the minimum number
+// of visible items needed, e.g. when not scrolled 5 items with
+// 20px fill 100px but when scrolled 6 items are needed
+const getNumberOfVisibleItems = (listHeight, itemHeight) => {
+  return Math.ceil(listHeight / itemHeight) + 1;
+};
+
+const Disk = 'file';
+
+const RE_PROTOCOL = /^([a-z-]+):\/\//;
+const getProtocol = uri => {
+  if (!uri) {
+    return Disk;
+  }
+  const protocolMatch = uri.match(RE_PROTOCOL);
+  if (protocolMatch) {
+    return protocolMatch[1];
+  }
+  return Disk;
+};
+
+const get = key => {
+  return false;
+};
+
+const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
+  }
+  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
+};
+
+const getGroups$2 = (providerId, path) => {
+  return executeProvider({
+    event: 'none',
+    method: SourceControlGetGroups,
+    params: [providerId, path]
+    // noProviderFoundMessage: 'No source control provider found',
+  });
+};
+const getEnabledProviderIds$1 = (scheme, root) => {
+  return executeProvider({
+    event: `onSourceControl:${scheme}`,
+    method: SourceControlGetEnabledProviderIds,
+    params: [scheme, root]
+    // noProviderFoundMessage: 'No source control provider found',
+  });
+};
+
+const getEnabledProviderIds = (scheme, root) => {
+  string(scheme);
+  string(root);
+  return getEnabledProviderIds$1(scheme, root);
+};
+const getGroups$1 = (providerId, root) => {
+  return getGroups$2(providerId, root);
+};
+
+const getExtensions = async () => {
+  return invoke('Extensions.getExtensions');
+};
+
+const state = {
+  cache: Object.create(null)
+};
+const getContextId = (groupId, type) => {
+  if (type === File) {
+    return `${groupId}-item`;
+  }
+  return groupId;
+};
+const ensureActions = async () => {
+  if (Object.keys(state.cache).length > 0) {
+    return;
+  }
+  const extensions = await getExtensions();
+  for (const extension of extensions) {
+    if (extension && extension['source-control-actions']) {
+      for (const [key, value] of Object.entries(extension['source-control-actions'])) {
+        state.cache[key] = value;
+      }
+    }
+  }
+};
+const getSourceControlActions = async (providerId, groupId, type) => {
+  string(groupId);
+  await ensureActions();
+  const contextId = getContextId(groupId, type);
+  const value = state.cache[contextId] || [];
+  return value;
+};
+
+const getGroups = async enabledProviderIds => {
+  const allGroups = [];
+  for (const providerId of enabledProviderIds) {
+    // @ts-ignore
+    const groups = await getGroups$1(providerId);
+    allGroups.push(...groups);
+  }
+  return {
+    allGroups,
+    gitRoot: ''
+  };
+};
+const getNewButtons = async (displayItems, providerId, buttonIndex) => {
+  if (buttonIndex === -1) {
+    return [];
+  }
+  const item = displayItems[buttonIndex];
+  if (!item) {
+    return [];
+  }
+  const actions = await getSourceControlActions(providerId, item.groupId, item.type);
+  return actions;
+};
+const loadContent = async state => {
+  const {
+    itemHeight,
+    height,
+    minimumSliderSize,
+    workspacePath
+  } = state;
+  const root = workspacePath;
+  const scheme = getProtocol(root);
+  const enabledProviderIds = await getEnabledProviderIds(scheme, root);
+  const {
+    allGroups,
+    gitRoot
+  } = await getGroups(enabledProviderIds);
+  const isExpanded = true;
+  const items = getDisplayItems(allGroups);
+  const buttons = await getNewButtons(items, state.providerId, state.buttonIndex);
+  const splitButtonEnabled = get();
+  const total = items.length;
+  const contentHeight = total * itemHeight;
+  const listHeight = getListHeight(total, itemHeight, height);
+  const scrollBarHeight = getScrollBarSize(height, contentHeight, minimumSliderSize);
+  const numberOfVisible = getNumberOfVisibleItems(listHeight, itemHeight);
+  const maxLineY = Math.min(numberOfVisible, total);
+  const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, total);
+  return {
+    ...state,
+    allGroups,
+    gitRoot,
+    items,
+    enabledProviderIds,
+    isExpanded,
+    buttons,
+    root,
+    splitButtonEnabled,
+    maxLineY,
+    scrollBarHeight,
+    finalDeltaY
+  };
+};
+
+const handleButtonClick = async (state, clickedIndex) => {
+  const {
+    buttonIndex,
+    buttons,
+    items
+  } = state;
+  const button = buttons[clickedIndex];
+  const item = items[buttonIndex];
+  if (!button) {
+    return state;
+  }
+  await executeCommand(button.command, item.file);
+  const newState = await loadContent(state);
+  return newState;
+};
+
+const show = async (x, y, id, ...args) => {
+  return invoke$1('ContextMenu.show', x, y, id, ...args);
+};
+
+const SourceControl = 22;
+
+const handleContextMenu = async (state, button, x, y) => {
+  await show(x, y, SourceControl);
+  return state;
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const sendMessagePortToExtensionHostWorker = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, DebugWorker);
+};
+
+const createExtensionHostRpc = async () => {
+  try {
+    const {
+      port1,
+      port2
+    } = getPortTuple();
+    await sendMessagePortToExtensionHostWorker(port2);
+    port1.start();
+    const rpc = await MessagePortRpcParent.create({
+      commandMap: {},
+      messagePort: port1,
+      isMessagePortOpen: false
+    });
+    // TODO createMessageportRpcParent should call port start
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
+};
+
+const initialize = async () => {
+  const extensionHostRpc = await createExtensionHostRpc();
+  set(ExtensionHostWorker, extensionHostRpc);
+};
+
+const HandleClick = 'handleClick';
+const HandleContextMenu = 'handleContextMenu';
+const HandleMouseOut = 'handleMouseOut';
+const HandleMouseOver = 'handleMouseOver';
+const HandleWheel = 'handleWheel';
+
+const None = 'none';
+const ToolBar = 'toolbar';
+const Tree = 'tree';
+const TreeItem$1 = 'treeitem';
+
+const Actions = 'Actions';
+const Chevron = 'Chevron';
+const ChevronRight = 'ChevronRight';
+const DecorationIcon = 'DecorationIcon';
+const FileIcon = 'FileIcon';
+const IconButton = 'IconButton';
+const InputBox = 'InputBox';
+const Label = 'Label';
+const LabelDetail = 'LabelDetail';
+const MaskIcon = 'MaskIcon';
+const MaskIconChevronDown = 'MaskIconChevronDown';
+const SourceControlBadge = 'SourceControlBadge';
+const SourceControlButton = 'SourceControlButton';
+const SourceControlHeader = 'SourceControlHeader';
+const SourceControlItems = 'SourceControlItems';
+const SplitButton = 'SplitButton';
+const SplitButtonContent = 'SplitButtonContent';
+const SplitButtonContentDisabled = 'SplitButtonContentDisabled';
+const SplitButtonDisabled = 'SplitButtonDisabled';
+const SplitButtonDropDown = 'SplitButtonDropDown';
+const SplitButtonDropDownDisabled = 'SplitButtonDropDownDisabled';
+const SplitButtonSeparator = 'SplitButtonSeparator';
+const StrikeThrough = 'StrikeThrough';
+const TreeItem = 'TreeItem';
+
+const emptySourceControlButtons = [];
+
+const Button$1 = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Img = 17;
+
+const Text = 12;
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const getBadgeVirtualDom = (className, count) => {
+  return [{
+    type: Div,
+    className: `Badge ${className}`,
+    childCount: 1
+  }, text(`${count}`)];
+};
+
+const getFileIconVirtualDom = icon => {
+  return {
+    type: Img,
+    className: FileIcon,
+    src: icon,
+    role: None,
+    childCount: 0
+  };
+};
+
+const getIconVirtualDom = (icon, type = Div) => {
+  return {
+    type,
+    className: `MaskIcon MaskIcon${icon}`,
+    role: None,
+    childCount: 0
+  };
+};
+
+const PaddingLeft = '1rem';
+const PaddingRight = '12px';
+
+const getLabelClassName = decorationStrikeThrough => {
+  let className = Label + ' Grow';
+  if (decorationStrikeThrough) {
+    className += ` ${StrikeThrough}`;
+  }
+  return className;
+};
+const addButtons = (dom, buttons) => {
+  if (buttons === emptySourceControlButtons) {
+    return;
+  }
+  dom[0].childCount += buttons.length;
+  for (const button of buttons) {
+    const {
+      icon,
+      label
+    } = button;
+    dom.push({
+      type: Button$1,
+      className: SourceControlButton,
+      title: label,
+      ariaLabel: label,
+      childCount: 1
+    }, getIconVirtualDom(icon, Span));
+  }
+};
+const createItemDirectory = item => {
+  const {
+    posInSet,
+    setSize,
+    icon,
+    label,
+    badgeCount,
+    decorationStrikeThrough,
+    type,
+    buttons
+  } = item;
+  const labelClassName = getLabelClassName(decorationStrikeThrough);
+  const dom = [{
+    type: Div,
+    className: TreeItem,
+    role: TreeItem$1,
+    ariaExpanded: type === DirectoryExpanded,
+    ariaPosInSet: posInSet,
+    ariaSetSize: setSize,
+    childCount: 3,
+    paddingLeft: PaddingLeft,
+    paddingRight: PaddingRight
+  }, {
+    type: Div,
+    className: `${Chevron} MaskIcon${icon}`,
+    childCount: 0
+  }, {
+    type: Div,
+    className: labelClassName,
+    childCount: 1
+  }, text(label)];
+  addButtons(dom, buttons);
+  dom.push(...getBadgeVirtualDom(SourceControlBadge, badgeCount));
+  return dom;
+};
+const createItemOther = item => {
+  const {
+    posInSet,
+    setSize,
+    icon,
+    file,
+    label,
+    decorationIcon,
+    decorationIconTitle,
+    decorationStrikeThrough,
+    detail,
+    buttons
+  } = item;
+  const labelClassName = getLabelClassName(decorationStrikeThrough);
+  /**
+   * @type {any[]}
+   */
+  const dom = [];
+  dom.push({
+    type: Div,
+    className: TreeItem,
+    role: TreeItem$1,
+    ariaPosInSet: posInSet,
+    ariaSetSize: setSize,
+    title: file,
+    childCount: 3,
+    paddingLeft: '1rem',
+    paddingRight: '12px'
+  }, ...(icon === ChevronRight ? [{
+    type: Div,
+    className: Chevron,
+    childCount: 1
+  }, getIconVirtualDom(icon)] : [getFileIconVirtualDom(icon)]));
+  const labelDom = {
+    type: Div,
+    className: labelClassName,
+    childCount: 1
+  };
+  dom.push(labelDom, text(label));
+  if (detail) {
+    labelDom.childCount++;
+    dom.push({
+      type: Span,
+      className: LabelDetail,
+      childCount: 1
+    }, text(detail));
+  }
+  addButtons(dom, buttons);
+  dom.push({
+    type: Img,
+    className: DecorationIcon,
+    title: decorationIconTitle,
+    src: decorationIcon,
+    childCount: 0
+  });
+  return dom;
+};
+const getSourceControlItemVirtualDom = item => {
+  switch (item.type) {
+    case DirectoryExpanded:
+    case Directory:
+      return createItemDirectory(item);
+    default:
+      return createItemOther(item);
+  }
+};
+
+const getSourceControlItemsVirtualDom$1 = (hasItems, buttonText) => {
+  const dom = [];
+  dom.push({
+    type: Div,
+    className: `${SplitButton} ${hasItems ? '' : SplitButtonDisabled}`,
+    childCount: 3
+  }, {
+    type: Div,
+    className: `${SplitButtonContent} ${hasItems ? '' : SplitButtonContentDisabled}`,
+    childCount: 1,
+    tabIndex: 0
+  }, text(buttonText), {
+    type: Div,
+    className: SplitButtonSeparator,
+    childCount: 0
+  }, {
+    type: Div,
+    className: `${SplitButtonDropDown} ${hasItems ? '' : SplitButtonDropDownDisabled}`,
+    childCount: 1,
+    tabIndex: 0
+  }, {
+    type: Div,
+    className: `${MaskIcon} ${MaskIconChevronDown}`,
+    childCount: 0
+  });
+  return dom;
+};
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+const MessageEnterToCommitOnMaster = `Message (Enter) to commit on 'master'`;
+const SourceControlInput = 'Source Control Input';
+
+const messageEnterToCommitOnMaster = () => {
+  return i18nString(MessageEnterToCommitOnMaster);
+};
+const sourceControlInput = () => {
+  return i18nString(SourceControlInput);
+};
+
+const getSourceControlItemsVirtualDom = (items, splitButtonEnabled) => {
+  const dom = [];
+  dom.push({
+    type: Div,
+    className: SourceControlHeader,
+    childCount: 1
+  }, {
+    type: Input,
+    className: InputBox,
+    spellcheck: false,
+    autocapitalize: 'off',
+    autocorrect: 'off',
+    placeholder: messageEnterToCommitOnMaster(),
+    ariaLabel: sourceControlInput(),
+    childCount: 0,
+    onInput: 'handleInput',
+    onFocus: 'handleFocus'
+  });
+  if (splitButtonEnabled) {
+    const hasItems = items.length > 0;
+    dom.push(...getSourceControlItemsVirtualDom$1(hasItems, 'Commit'));
+  }
+  dom.push({
+    type: Div,
+    className: SourceControlItems,
+    role: Tree,
+    childCount: items.length
+  }, ...items.flatMap(getSourceControlItemVirtualDom));
+  return dom;
+};
+
+const getSourceControlVirtualDom = (items, splitButtonEnabled) => {
+  const dom = [{
+    type: Div,
+    className: 'Viewlet SourceControl',
+    tabIndex: 0,
+    onClick: HandleClick,
+    onContextMenu: HandleContextMenu,
+    onMouseOver: HandleMouseOver,
+    onMouseOut: HandleMouseOut,
+    onWheel: HandleWheel,
+    childCount: splitButtonEnabled ? 3 : 2
+  }, ...getSourceControlItemsVirtualDom(items, splitButtonEnabled)];
+  return dom;
+};
+
+const getVisibleSourceControlItems = (items, minLineY, maxLineY, buttons, buttonIndex) => {
+  const visible = [];
+  for (let i = minLineY; i < maxLineY; i++) {
+    const item = items[i];
+    const itemButtons = i === buttonIndex ? buttons : emptySourceControlButtons;
+    visible.push({
+      ...item,
+      buttons: itemButtons
+    });
+  }
+  return visible;
+};
+
+const renderItems = (oldState, newState) => {
+  const visible = getVisibleSourceControlItems(newState.items, newState.minLineY, newState.maxLineY, newState.buttons, newState.buttonIndex);
+  const dom = getSourceControlVirtualDom(visible, newState.splitButtonEnabled);
+  return ['Viewlet.setDom2', 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 {
+    oldState,
+    newState
+  } = get$2(uid);
+  set$1(uid, newState, newState);
+  const commands = applyRender(oldState, newState, diffResult);
+  return commands;
+};
+
+const Button = 1;
+
+const getActionButtonVirtualDom = action => {
+  const {
+    id,
+    icon,
+    command
+  } = action;
+  return [{
+    type: Button$1,
+    className: IconButton,
+    title: id,
+    'data-command': command,
+    childCount: 1
+  }, getIconVirtualDom(icon)];
+};
+
+const getActionVirtualDom = action => {
+  switch (action.type) {
+    case Button:
+      return getActionButtonVirtualDom(action);
+    default:
+      return [];
+  }
+};
+
+const getActionsVirtualDom = actions => {
+  return [{
+    type: Div,
+    className: Actions,
+    role: ToolBar,
+    childCount: actions.length
+  }, ...actions.flatMap(getActionVirtualDom)];
+};
+
+const renderActions = uid => {
+  const actions = [];
+  const dom = getActionsVirtualDom(actions);
+  return dom;
+};
+
+const renderEventListeners = () => {
+  return [{
+    name: HandleWheel,
+    params: ['handleWheel', 'event.deltaMode', 'event.deltaY'],
+    passive: true
+  }];
+};
+
+const saveState = uid => {
+  number(uid);
+  const value = get$2(uid);
+  const {
+    newState
+  } = value;
+  const {
+    root,
+    maxLineY
+  } = newState;
+  return {
+    root,
+    minLineY: 0,
+    maxLineY,
+    deltaY: 0
+  };
+};
+
+const terminate = () => {
+  globalThis.close();
+};
+
+const commandMap = {
+  'Initialize.initialize': initialize,
+  'SourceControl.create2': create2,
+  'SourceControl.diff2': diff2,
+  'SourceControl.getCommandIds': getCommandIds,
+  'SourceControl.handleButtonClick': wrapCommand(handleButtonClick),
+  'SourceControl.handleContextMenu': wrapCommand(handleContextMenu),
+  'SourceControl.loadContent': wrapCommand(loadContent),
+  'SourceControl.render2': render2,
+  'SourceControl.renderActions2': renderActions,
+  'SourceControl.renderEventListeners': renderEventListeners,
+  'SourceControl.saveState': saveState,
+  'SourceControl.terminate': terminate
+};
 
 const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/source-control-worker",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Source Control Worker",
   "keywords": [
     "Lvce Editor"