@lvce-editor/settings-view 1.0.0 → 1.2.0

package/dist/settingsViewWorkerMain.js

@@ -378,32 +378,32 @@ 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$1 = id => {
+const get$2 = 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$1(id, resolve);
+  set$2(id, resolve);
   return {
     id,
     promise
   };
 };
-const create$2 = (method, params) => {
+const create$2$1 = (method, params) => {
   const {
     id,
     promise
@@ -561,7 +561,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$1(id);
+  const fn = get$2(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -728,7 +728,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 {
@@ -815,7 +815,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$1 = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -827,10 +827,398 @@ const create$1 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$1
+  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 {
+          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;
+    },
+    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$1,
+  set: set$1,
+  wrapCommand,
+  getCommandIds,
+  registerCommands
+} = create$2();
+
+const create$1 = (id, uri, x, y, width, height) => {
+  const state = {
+    breakPointsExpanded: false,
+    breakPointsVisible: false,
+    focus: 0,
+    id,
+    uri,
+    x,
+    y,
+    width,
+    height
+  };
+  set$1(id, state, state);
+};
+
+const isEqual$1 = (oldState, newState) => {
+  return oldState.focus === newState.focus;
+};
+
+const isEqual = (oldState, newState) => {
+  return oldState === newState;
+};
+
+const RenderItems = 1;
+const RenderFocus = 2;
+
+const modules = [isEqual$1, isEqual];
+const numbers = [RenderFocus, 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 {
+    oldState,
+    newState
+  } = get$1(uid);
+  const diffResult = diff(oldState, newState);
+  return diffResult;
+};
+
+const initialize = async () => {
+  // TODO
+};
+
+const loadContent = async (state, savedState) => {
+  return {
+    ...state
+  };
+};
+
+const Viewlet$1 = 'Viewlet';
+const ClassNames = {
+  __proto__: null,
+  Viewlet: Viewlet$1};
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+const Div = 4;
+const H1 = 5;
+const Text = 12;
+const VirtualDomElements = {
+  __proto__: null,
+  Div,
+  H1};
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const {
+  Viewlet} = ClassNames;
+const Settings = 'Settings';
+
+const getSettingsDom = state => {
+  return [{
+    type: VirtualDomElements.Div,
+    childCount: 1,
+    className: mergeClassNames(Viewlet, Settings)
+  }, {
+    type: VirtualDomElements.H1,
+    childCount: 1
+  }, text('Settings Dom: TODO')];
+};
+
+const renderItems = (oldState, newState) => {
+  const dom = getSettingsDom();
+  return ['Viewlet.setDom2', newState.id, 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);
+    commands.push(fn(oldState, newState));
+  }
+  return commands;
+};
+
+const render2 = (uid, diffResult) => {
+  const {
+    oldState,
+    newState
+  } = get$1(uid);
+  set$1(uid, newState, newState);
+  const commands = applyRender(oldState, newState, diffResult);
+  return commands;
+};
+
+const renderActions = () => {
+  return [];
+};
+
+const HandleClickCallStackItem = 'handleClickCallStackItem';
+const HandleClickWatchExpression = 'handleClickWatchExpression';
+const HandleClickWatchExpressionDelete = 'handleClickWatchExpressionDelete';
+const HandleClickCheckBox = 'handleClickCheckBox';
+const HandleClickContinue = 'handleClickContinue';
+const HandleClickDebugButton = 'handleClickDebugButton';
+const HandleClickPause = 'handleClickPause';
+const HandleClickScopeValue = 'handleClickScopeValue';
+const HandleClickSectionBreakPoints = 'handleClickSectionBreakPoints';
+const HandleClickSectionCallstack = 'handleClickSectionCallstack';
+const HandleClickSectionHeading = 'handleClickSectionHeading';
+const HandleClickSectionScope = 'handleClickSectionScope';
+const HandleClickSectionWatch = 'handleClickSectionWatch';
+const HandleClickStepInto = 'handleClickStepInto';
+const HandleClickStepOut = 'handleClickStepOut';
+const HandleClickStepOver = 'handleClickStepOver';
+const HandleDebugInput = 'handleDebugInput';
+const HandleClickSectionAction = 'handleClickSectionAction';
+const HandleInputFieldChange = 'handleInputFieldChange';
+const HandleInputBlur = 'handleInputBlur';
+const HandleSectionHeaderContextMenu = 'handleSectionHeaderContextMenu';
+const HandleWatchExpressionContextMenu = 'handleWatchExpressionContextMenu';
+
+// TODo use numeric ids
+
+const renderEventListeners = () => {
+  return [{
+    name: HandleClickContinue,
+    params: ['handleClickContinue']
+  }, {
+    name: HandleClickDebugButton,
+    params: ['handleClickDebugButton', 'event.target.name']
+  }, {
+    name: HandleClickPause,
+    params: ['handleClickPause']
+  }, {
+    name: HandleClickStepOver,
+    params: ['handleClickStepOver']
+  }, {
+    name: HandleClickStepInto,
+    params: ['handleClickStepInto']
+  }, {
+    name: HandleClickStepOut,
+    params: ['handleClickStepOut']
+  }, {
+    name: HandleClickSectionWatch,
+    params: ['HandleClickSectionWatch']
+  }, {
+    name: HandleClickSectionBreakPoints,
+    params: ['handleClickSectionBreakpoints']
+  }, {
+    name: HandleClickSectionScope,
+    params: ['handleClickSectionScope']
+  }, {
+    name: HandleClickSectionCallstack,
+    params: ['handleClickSectionCallstack']
+  }, {
+    name: HandleClickSectionBreakPoints,
+    params: ['handleClickSectionBreakPoints']
+  }, {
+    name: HandleDebugInput,
+    params: ['handleDebugInput', 'event.target.value']
+  }, {
+    name: HandleClickSectionHeading,
+    params: ['handleClickSectionHeading', 'event.target.dataset.name', 'event.button'],
+    preventDefault: true
+  }, {
+    name: HandleClickCheckBox,
+    params: ['handleClickCheckBox', 'event.target.name']
+  }, {
+    name: HandleClickDebugButton,
+    params: ['handleClickDebugButton', 'event.target.name']
+  }, {
+    name: HandleClickCallStackItem,
+    params: ['handleClickCallStackItem', 'event.target.dataset.index']
+  }, {
+    name: HandleClickWatchExpression,
+    params: ['handleClickWatchExpression', 'event.target.dataset.index', 'event.defaultPrevented']
+  }, {
+    name: HandleClickWatchExpressionDelete,
+    params: ['handleClickWatchExpressionDelete', 'event.target.dataset.index'],
+    preventDefault: true
+  }, {
+    name: HandleClickScopeValue,
+    params: ['handleClickScopeValue', 'event.target.dataset.index', 'event.button']
+  }, {
+    name: HandleInputFieldChange,
+    params: ['handleInputFieldChange', 'event.target.name', 'event.target.value']
+  }, {
+    name: HandleClickSectionAction,
+    params: ['handleClickSectionAction', 'event.target.name']
+  }, {
+    name: HandleInputBlur,
+    params: ['handleInputBlur']
+  }, {
+    name: HandleSectionHeaderContextMenu,
+    params: ['handleSectionHeaderContextMenu', 'event.clientX', 'event.clientY', 'event.target.dataset.name'],
+    preventDefault: true
+  }, {
+    name: HandleWatchExpressionContextMenu,
+    params: ['handleWatchExpressionContextMenu', 'event.clientX', 'event.clientY', 'event.target.dataset.index'],
+    preventDefault: true
+  }];
+};
+
+const getSavedMinLineY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'minLineY' in savedState && typeof savedState.minLineY === 'number') {
+    return savedState.minLineY;
+  }
+  return 0;
+};
+const getSavedDeltaY = savedState => {
+  if (savedState && typeof savedState === 'object' && 'deltaY' in savedState && typeof savedState.deltaY === 'number') {
+    return savedState.deltaY;
+  }
+  return 0;
+};
+const getSavedWorkspacePath = savedState => {
+  if (savedState && typeof savedState === 'object' && 'workspacePath' in savedState && typeof savedState.workspacePath === 'string') {
+    return savedState.workspacePath;
+  }
+  return '';
+};
+const restoreState = savedState => {
+  if (!savedState) {
+    return {
+      root: '',
+      minLineY: 0,
+      deltaY: 0
+    };
+  }
+  const root = getSavedWorkspacePath(savedState);
+  const minLineY = getSavedMinLineY(savedState);
+  const deltaY = getSavedDeltaY(savedState);
+  return {
+    root,
+    minLineY,
+    deltaY
+  };
+};
+
+const saveState = uid => {
+  return {
+    expandedPaths: [],
+    root: '',
+    minLineY: 0,
+    maxLineY: 0,
+    deltaY: 0
+  };
+};
+
+const commandMap = {
+  'Initialize.initialize': initialize,
+  'Settings.create': create$1,
+  'Settings.diff2': diff2,
+  'Settings.getCommandIds': getCommandIds,
+  'Settings.loadContent': wrapCommand(loadContent),
+  'Settings.render2': render2,
+  'Settings.renderActions': renderActions,
+  'Settings.renderEventListeners': renderEventListeners,
+  'Settings.restoreState': restoreState,
+  'Settings.saveState': saveState,
+  'Settings.terminate': terminate
+};
 
 const rpcs = Object.create(null);
 const set$g = (id, rpc) => {
@@ -873,9 +1261,11 @@ const RendererWorker = {
   set: set$3};
 
 const {
-  set} = RendererWorker;
+  set
+} = RendererWorker;
 
 const listen = async () => {
+  registerCommands(commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/settings-view",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",