@lvce-editor/source-control-worker 1.0.0 → 1.1.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) => {
@@ -392,7 +527,7 @@ const callbacks = Object.create(null);
 const set$1 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get = id => {
+const get$2 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -565,7 +700,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -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,6 +928,26 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+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 = async ({
   commandMap
 }) => {
@@ -808,20 +963,358 @@ const WebWorkerRpcClient = {
   create
 };
 
-const terminate = () => {
-  globalThis.close();
-};
-
-const commandMap = {
-  'SourceControl.terminate': terminate
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
 };
 
 const RendererWorker = 1;
+const ExtensionHostWorker = 44;
+const DebugWorker = 55;
+const SourceControlWorker = 66;
 
 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 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(SourceControlWorker, extensionHostRpc);
+};
+
+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 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 SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
+const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
+
+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 terminate = () => {
+  globalThis.close();
+};
+
+const commandMap = {
+  'Initialize.initialize': initialize,
+  'SourceControl.loadControl': loadContent,
+  '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.1.0",
   "description": "Source Control Worker",
   "keywords": [
     "Lvce Editor"