@lvce-editor/settings-view 1.0.0 → 1.1.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,232 @@ 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 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 getSettingsDom = state => {
+  return [{
+    type: VirtualDomElements.Div,
+    childCount: 1
+  }, {
+    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 commandMap = {
+  'Initialize.initialize': initialize,
+  'Settings.create': create$1,
+  'Settings.getCommandIds': getCommandIds,
+  'Settings.terminate': terminate,
+  'Settings.diff2': diff2,
+  'Settings.loadContent': wrapCommand(loadContent),
+  'Settings.renderActions': renderActions,
+  'Settings.render2': render2
+};
 
 const rpcs = Object.create(null);
 const set$g = (id, rpc) => {
@@ -873,9 +1095,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.1.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",