@lvce-editor/panel-worker 1.11.0 → 2.2.0

package/dist/panelWorkerMain.js

@@ -145,7 +145,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -299,7 +298,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -492,7 +498,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -509,8 +518,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -521,55 +532,91 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   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;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -884,21 +931,6 @@ const create$3 = async ({
   return rpc;
 };
 
-const Tab = 'tab';
-const TabList = 'tablist';
-const ToolBar = 'toolbar';
-
-const Button = 1;
-const Div = 4;
-const Text = 12;
-const Reference = 100;
-
-const TargetName = 'event.target.name';
-
-const RendererWorker = 1;
-
-const SetPatches = 'Viewlet.setPatches';
-
 const createMockRpc = ({
   commandMap
 }) => {
@@ -967,6 +999,21 @@ const create$2 = rpcId => {
   };
 };
 
+const Tab = 'tab';
+const TabList = 'tablist';
+const ToolBar = 'toolbar';
+
+const Button = 1;
+const Div = 4;
+const Text = 12;
+const Reference = 100;
+
+const TargetName = 'event.target.name';
+
+const RendererWorker = 1;
+
+const SetPatches = 'Viewlet.setPatches';
+
 const {
   invoke,
   set: set$1
@@ -1012,7 +1059,7 @@ const create$1 = () => {
     },
     getKeys() {
       return Object.keys(states).map(key => {
-        return Number.parseInt(key);
+        return Number.parseFloat(key);
       });
     },
     registerCommands(commandMap) {
@@ -1054,6 +1101,37 @@ const create$1 = () => {
         return fn(newState, ...args);
       };
       return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
     }
   };
 };
@@ -1078,8 +1156,10 @@ const create = (uid, uri, x, y, width, height, platform, assetDir) => {
     childUid: 0,
     currentViewletId: '',
     errorCount: 0,
+    headerHeight: 35,
     height: 0,
     initial: true,
+    maximized: false,
     platform,
     selectedIndex: -1,
     tabs: [],
@@ -1093,20 +1173,25 @@ const create = (uid, uri, x, y, width, height, platform, assetDir) => {
   set(uid, state, state);
 };
 
+const isEqual$2 = (oldState, newState) => {
+  return oldState.actionsUid === newState.actionsUid;
+};
+
 const isEqual$1 = (oldState, newState) => {
   return oldState.childUid === newState.childUid;
 };
 
 const isEqual = (oldState, newState) => {
-  return oldState.assetDir === newState.assetDir && oldState.initial === newState.initial && oldState.currentViewletId === newState.currentViewletId && oldState.selectedIndex === newState.selectedIndex && oldState.views === newState.views && oldState.childUid === newState.childUid && oldState.actionsUid === newState.actionsUid;
+  return oldState.assetDir === newState.assetDir && oldState.initial === newState.initial && oldState.currentViewletId === newState.currentViewletId && oldState.maximized === newState.maximized && oldState.selectedIndex === newState.selectedIndex && oldState.views === newState.views && oldState.childUid === newState.childUid && oldState.actionsUid === newState.actionsUid;
 };
 
 const RenderItems = 4;
 const RenderIncremental = 11;
 const RenderChildUid = 12;
+const RenderActionsUid = 13;
 
-const modules = [isEqual, isEqual$1];
-const numbers = [RenderIncremental, RenderChildUid];
+const modules = [isEqual, isEqual$1, isEqual$2];
+const numbers = [RenderIncremental, RenderChildUid, RenderActionsUid];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1137,6 +1222,26 @@ const handleClickMaximize = async state => {
   await invoke('Layout.maximizePanel');
   return state;
 };
+const handleClickUnmaximize = async state => {
+  await invoke('Layout.unmaximizePanel');
+  return state;
+};
+
+const handlePanelLayoutChanged = (state, change) => {
+  const {
+    maximized: currentMaximized
+  } = state;
+  const {
+    maximized
+  } = change;
+  if (currentMaximized === maximized) {
+    return state;
+  }
+  return {
+    ...state,
+    maximized
+  };
+};
 
 const handleBlur = async state => {
   return state;
@@ -1170,26 +1275,33 @@ const getSavedViewletId = savedState => {
   return Problems;
 };
 
-const createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
-  await invoke('Layout.createViewlet', viewletModuleId, editorUid, tabId, bounds, uri);
+const createViewlet = async (viewletModuleId, editorUid, tabId, actionsUid, bounds, uri) => {
+  await invoke('Layout.createPanelViewlet', viewletModuleId, editorUid, tabId, actionsUid, bounds, uri);
 };
 
 const getContentDimensions = dimensions => {
   return {
-    height: dimensions.height - 35,
+    height: dimensions.height - dimensions.headerHeight,
     width: dimensions.width,
     x: dimensions.x,
-    y: dimensions.y + 35
+    y: dimensions.y + dimensions.headerHeight
   };
 };
 
+const getUid = () => {
+  return Math.random();
+};
+
 const openViewlet = async (state, id, focus = false) => {
+  const {
+    views
+  } = state;
   const childDimensions = getContentDimensions(state);
-  const childUid = Math.random();
-  const tabId = Math.random();
-  const actionsUid = Math.random();
-  const index = state.views.indexOf(id);
-  await createViewlet(id, childUid, tabId, childDimensions, '');
+  const childUid = getUid();
+  const tabId = getUid();
+  const actionsUid = getUid();
+  const index = views.indexOf(id);
+  await createViewlet(id, childUid, tabId, actionsUid, childDimensions, '');
   return {
     ...state,
     actionsUid,
@@ -1219,7 +1331,7 @@ const selectIndex = async (state, index) => {
 };
 
 const selectRaw = async (state, rawIndex) => {
-  return selectIndex(state, Number.parseInt(rawIndex, 10));
+  return selectIndex(state, Number(rawIndex));
 };
 
 const setBadgeCount = (state, id, count) => {
@@ -1236,16 +1348,28 @@ const setBadgeCount = (state, id, count) => {
 };
 
 const toggleView = async (state, name) => {
-  const index = state.views.indexOf(name);
+  const {
+    currentViewletId,
+    views
+  } = state;
+  const index = views.indexOf(name);
   if (index === -1) {
     return state;
   }
-  if (name === state.currentViewletId) {
+  if (name === currentViewletId) {
     return state;
   }
   return selectIndex(state, index);
 };
 
+const renderActionsUid = (oldState, newState) => {
+  const oldActionsUid = oldState.actionsUid;
+  if (oldActionsUid <= 0 || oldActionsUid === newState.actionsUid) {
+    return [];
+  }
+  return ['Viewlet.dispose', oldActionsUid];
+};
+
 // TODO also need to dispose child when panel becomes hidden
 const renderChildUid = (oldState, newState) => {
   const oldChildUid = oldState.childUid;
@@ -1489,7 +1613,6 @@ const diffChildren = (oldChildren, newChildren, patches) => {
     patches.push({
       type: NavigateParent
     });
-    currentChildIndex = -1;
   }
   // Add remove patches in reverse order (highest index first)
   // This ensures indices remain valid as we remove
@@ -1566,17 +1689,19 @@ const IconButton = 'IconButton';
 const MaskIcon = 'MaskIcon';
 const MaskIconChevronUp = 'MaskIconChevronUp';
 const MaskIconClose = 'MaskIconClose';
+const MaskIconRestore = 'MaskIconRestore';
 const Actions = 'Actions';
 
+const emptyActionsNode = {
+  childCount: 0,
+  className: Actions,
+  role: ToolBar,
+  type: Div
+};
 const getActionsDom = newState => {
   const actions = newState.actionsUid || -1;
-  if (actions === -1 || Map) {
-    return [{
-      childCount: 0,
-      className: Actions,
-      role: ToolBar,
-      type: Div
-    }];
+  if (actions <= 0) {
+    return [emptyActionsNode];
   }
   return [{
     type: Reference,
@@ -1586,6 +1711,7 @@ const getActionsDom = newState => {
 
 const HandleClickClose = 'handleClickClose';
 const HandleClickMaximize = 'handleClickMaximize';
+const HandleClickUnmaximize = 'handleClickUnmaximize';
 const HandleClickSelectTab = 'HandleClickSelectTab';
 const HandleClickTab = 'HandleClickTab';
 
@@ -1602,31 +1728,42 @@ const i18nString = (key, placeholders = emptyObject) => {
 };
 
 const Maximize = 'Maximize';
+const Unmaximize = 'Unmaximize';
 const Close = 'Close';
 
 const maximize = () => {
   return i18nString(Maximize);
 };
+const unmaximize = () => {
+  return i18nString(Unmaximize);
+};
 const close = () => {
   return i18nString(Close);
 };
 
-const getGlobalActionsDom = () => {
-  return [{
-    childCount: 2,
-    className: PanelToolBar,
-    role: ToolBar,
-    type: Div
-  }, {
-    ariaLabel: maximize(),
+const panelToolBarNode = {
+  childCount: 2,
+  className: PanelToolBar,
+  role: ToolBar,
+  type: Div
+};
+const getGlobalActionsDom = state => {
+  const {
+    maximized
+  } = state;
+  const maximizeLabel = maximized ? unmaximize() : maximize();
+  const maximizeOnClick = maximized ? HandleClickUnmaximize : HandleClickMaximize;
+  const maximizeIcon = maximized ? MaskIconRestore : MaskIconChevronUp;
+  return [panelToolBarNode, {
+    ariaLabel: maximizeLabel,
     childCount: 1,
     className: IconButton,
-    onClick: HandleClickMaximize,
-    title: maximize(),
+    onClick: maximizeOnClick,
+    title: maximizeLabel,
     type: Button
   }, {
     childCount: 0,
-    className: mergeClassNames(MaskIcon, MaskIconChevronUp),
+    className: mergeClassNames(MaskIcon, maximizeIcon),
     type: Div
   }, {
     ariaLabel: close(),
@@ -1645,12 +1782,17 @@ const getGlobalActionsDom = () => {
 const getTabClassName = isSelected => {
   let className = PanelTab;
   if (isSelected) {
-    className += ' ' + PanelTabSelected;
+    className = mergeClassNames(className, PanelTabSelected);
   }
   return className;
 };
 
-const createPanelTab = (tab, badgeCount, isSelected, index) => {
+const badgeNode = {
+  childCount: 1,
+  className: Badge,
+  type: Div
+};
+const createPanelTab = (tab, badgeCount, isSelected) => {
   const label = tab;
   const className = getTabClassName(isSelected);
   const childCount = badgeCount ? 2 : 1;
@@ -1658,7 +1800,6 @@ const createPanelTab = (tab, badgeCount, isSelected, index) => {
     ariaSelected: isSelected,
     childCount,
     className,
-    'data-index': index,
     name: tab,
     onClick: HandleClickTab,
     role: Tab,
@@ -1666,11 +1807,7 @@ const createPanelTab = (tab, badgeCount, isSelected, index) => {
   };
   const dom = [tabDom, text(label)];
   if (badgeCount) {
-    dom.push({
-      childCount: 1,
-      className: Badge,
-      type: Div
-    }, text(' ' + badgeCount));
+    dom.push(badgeNode, text(' ' + badgeCount));
   }
   return dom;
 };
@@ -1681,34 +1818,36 @@ const getPanelTabsVirtualDom = (tabs, selectedIndex, badgeCounts) => {
     const isSelected = i === selectedIndex;
     const tab = tabs[i];
     const badgeCount = badgeCounts[tab] || 0;
-    dom.push(...createPanelTab(tab, badgeCount, isSelected, i));
+    dom.push(...createPanelTab(tab, badgeCount, isSelected));
   }
   return dom;
 };
 
+const panelHeaderNode = {
+  childCount: 3,
+  className: PanelHeader,
+  type: Div
+};
 const getPanelHeaderDom = newState => {
   const tabsDom = getPanelTabsVirtualDom(newState.views, newState.selectedIndex, newState.badgeCounts);
-  return [{
-    childCount: 3,
-    className: PanelHeader,
-    type: Div
-  }, {
+  return [panelHeaderNode, {
     childCount: newState.views.length,
     className: PanelTabs,
     role: TabList,
     type: Div
-  }, ...tabsDom, ...getActionsDom(newState), ...getGlobalActionsDom()];
+  }, ...tabsDom, ...getActionsDom(newState), ...getGlobalActionsDom(newState)];
 };
 
+const panelNode = {
+  childCount: 2,
+  className: Panel,
+  type: Div
+};
 const getPanelDom = newState => {
   const {
     childUid
   } = newState;
-  return [{
-    childCount: 2,
-    className: Panel,
-    type: Div
-  }, ...getPanelHeaderDom(newState), {
+  return [panelNode, ...getPanelHeaderDom(newState), {
     type: Reference,
     uid: childUid
   }];
@@ -1734,6 +1873,8 @@ const renderIncremental = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderActionsUid:
+      return renderActionsUid;
     case RenderChildUid:
       return renderChildUid;
     case RenderIncremental:
@@ -1771,6 +1912,9 @@ const renderEventListeners = () => {
   return [{
     name: HandleClickMaximize,
     params: ['handleClickMaximize']
+  }, {
+    name: HandleClickUnmaximize,
+    params: ['handleClickUnmaximize']
   }, {
     name: HandleClickClose,
     params: ['handleClickClose']
@@ -1818,7 +1962,10 @@ const selectName = async (state, name) => {
   if (!name) {
     return state;
   }
-  const index = state.views.indexOf(name);
+  const {
+    views
+  } = state;
+  const index = views.indexOf(name);
   if (index === -1) {
     return state;
   }
@@ -1832,7 +1979,9 @@ const commandMap = {
   'Panel.handleBlur': wrapCommand(handleBlur),
   'Panel.handleClickClose': wrapCommand(handleClickClose),
   'Panel.handleClickMaximize': wrapCommand(handleClickMaximize),
+  'Panel.handleClickUnmaximize': wrapCommand(handleClickUnmaximize),
   'Panel.handleFilterInput': wrapCommand(handleFilterInput),
+  'Panel.handlePanelLayoutChanged': wrapCommand(handlePanelLayoutChanged),
   'Panel.loadContent': wrapCommand(loadContent),
   'Panel.openViewlet': wrapCommand(openViewlet),
   'Panel.render2': render2,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/panel-worker",
-  "version": "1.11.0",
+  "version": "2.2.0",
   "description": "Panel Worker",
   "repository": {
     "type": "git",
@@ -9,8 +9,5 @@
   "license": "MIT",
   "author": "Lvce Editor",
   "type": "module",
-  "main": "dist/panelWorkerMain.js",
-  "dependencies": {
-    "@lvce-editor/virtual-dom-worker": "^8.3.0"
-  }
+  "main": "dist/panelWorkerMain.js"
 }