@pronto-tools-and-more/diff-process 8.18.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@pronto-tools-and-more/diff-process",
+  "version": "8.18.0",
+  "description": "",
+  "main": "src/diffProcessMain.js",
+  "type": "module",
+  "scripts": {
+    "test": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --detectOpenHandles --forceExit",
+    "test:watch": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --watch",
+    "type-check": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@lvce-editor/ipc": "^11.1.0",
+    "@lvce-editor/json-rpc": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "jest": "^29.7.0"
+  }
+}

package/src/diffProcessMain.js

@@ -0,0 +1,3 @@
+import * as Main from "./parts/Main/Main.js";
+
+Main.main();

package/src/parts/Callback/Callback.js

@@ -0,0 +1 @@
+export { resolve } from "@lvce-editor/json-rpc";

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from "../CommandState/CommandState.js";
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command);
+  if (!fn) {
+    throw new Error(`Command not found ${command}`);
+  }
+  return fn(...args);
+};

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,5 @@
+import * as Diff from "../Diff/Diff.js";
+
+export const commandMap = {
+  "Diff.diff": Diff.diff,
+};

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,17 @@
+const state = {
+  commands: Object.create(null),
+};
+
+const registerCommand = (key, fn) => {
+  state.commands[key] = fn;
+};
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value);
+  }
+};
+
+export const getCommand = (key) => {
+  return state.commands[key];
+};

package/src/parts/Diff/Diff.js

@@ -0,0 +1,3 @@
+export const diff = (oldViews, newViews) => {
+  return [];
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,10 @@
+import * as HandleMessage from "../HandleMessage/HandleMessage.js";
+
+export const handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", HandleMessage.handleMessage);
+  } else if ("on" in ipc) {
+    // deprecated
+    ipc.on("message", HandleMessage.handleMessage);
+  }
+};

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,27 @@
+import * as Callback from "../Callback/Callback.js";
+import * as Command from "../Command/Command.js";
+import * as JsonRpc from "../JsonRpc/JsonRpc.js";
+
+const prepare = (error) => {
+  return error;
+};
+
+const requiresSocket = (method) => {
+  return false;
+};
+
+const logError = (error, prettyError) => {
+  console.error(error);
+};
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(
+    event.target,
+    event.data,
+    Command.execute,
+    Callback.resolve,
+    prepare,
+    logError,
+    requiresSocket,
+  );
+};

package/src/parts/Hash/Hash.js

@@ -0,0 +1,10 @@
+import { MurmurHash3 } from "../MurmurHash/MurmurHash.js";
+
+const seed = 48434; // Random int between 0 and 65535
+
+/**
+ * Hashes a string.
+ */
+export function hash(string) {
+  return MurmurHash3.hashString(string, string.length, seed);
+}

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,15 @@
+import * as IpcChildModule from "../IpcChildModule/IpcChildModule.js";
+
+export const listen = async ({ method, ...params }) => {
+  const module = await IpcChildModule.getModule(method);
+  // @ts-ignore
+  const rawIpc = await module.listen(params);
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,25 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from "@lvce-editor/ipc";
+import * as IpcChildType from "../IpcChildType/IpcChildType.js";
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess;
+    case IpcChildType.NodeWorker:
+      return IpcChildWithNodeWorker;
+    case IpcChildType.ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess;
+    case IpcChildType.ElectronMessagePort:
+      return IpcChildWithElectronMessagePort;
+    case IpcChildType.WebSocket:
+      return IpcChildWithWebSocket;
+    default:
+      throw new Error("unexpected ipc type");
+  }
+};

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,19 @@
+export const NodeWorker = 1;
+export const NodeForkedProcess = 2;
+export const ElectronUtilityProcess = 3;
+export const ElectronMessagePort = 4;
+export const WebSocket = 6;
+
+export const Auto = () => {
+  const { argv } = process;
+  if (argv.includes("--ipc-type=node-worker")) {
+    return NodeWorker;
+  }
+  if (argv.includes("--ipc-type=node-forked-process")) {
+    return NodeForkedProcess;
+  }
+  if (argv.includes("--ipc-type=electron-utility-process")) {
+    return ElectronUtilityProcess;
+  }
+  throw new Error(`[shared-process] unknown ipc type`);
+};

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/json-rpc";

package/src/parts/Listen/Listen.js

@@ -0,0 +1,8 @@
+import * as HandleIpc from "../HandleIpc/HandleIpc.js";
+import * as IpcChild from "../IpcChild/IpcChild.js";
+import * as IpcChildType from "../IpcChildType/IpcChildType.js";
+
+export const listen = async () => {
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() });
+  HandleIpc.handleIpc(ipc);
+};

package/src/parts/Main/Main.js

@@ -0,0 +1,8 @@
+import * as CommandMap from "../CommandMap/CommandMap.js";
+import * as CommandState from "../CommandState/CommandState.js";
+import * as Listen from "../Listen/Listen.js";
+
+export const main = async () => {
+  CommandState.registerCommands(CommandMap.commandMap);
+  await Listen.listen();
+};

package/src/parts/MurmurHash/MurmurHash.js

@@ -0,0 +1,120 @@
+/* Public Domain MurmurHash3 implementation. Altered to have AMD header and function wrapper. */
+
+/*
+ *  The MurmurHash3 algorithm was created by Austin Appleby.  This JavaScript port was authored
+ *  by Peter Zotov (based on Java port by Yonik Seeley) and is placed into the public domain.
+ *  The author hereby disclaims copyright to this source code.
+ *
+ *  This produces exactly the same hash values as the final C++ version of MurmurHash3 and
+ *  is thus suitable for producing the same hash values across platforms.
+ *
+ *  There are two versions of this hash implementation. First interprets the string as a
+ *  sequence of bytes, ignoring most significant byte of each codepoint. The second one
+ *  interprets the string as a UTF-16 codepoint sequence, and appends each 16-bit codepoint
+ *  to the hash independently. The latter mode was not written to be compatible with
+ *  any other implementation, but it should offer better performance for JavaScript-only
+ *  applications.
+ *
+ *  See http://github.com/whitequark/murmurhash3-js for future updates to this file.
+ */
+
+export const MurmurHash3 = {
+  mul32(m, n) {
+    const nlo = n & 0xffff;
+    const nhi = n - nlo;
+    return (((nhi * m) | 0) + ((nlo * m) | 0)) | 0;
+  },
+
+  hashBytes(data, len, seed) {
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+
+    let h1 = seed;
+    const roundedEnd = len & ~0x3;
+
+    for (let i = 0; i < roundedEnd; i += 4) {
+      var k1 =
+        (data.charCodeAt(i) & 0xff) |
+        ((data.charCodeAt(i + 1) & 0xff) << 8) |
+        ((data.charCodeAt(i + 2) & 0xff) << 16) |
+        ((data.charCodeAt(i + 3) & 0xff) << 24);
+
+      k1 = this.mul32(k1, c1);
+      k1 = ((k1 & 0x1ffff) << 15) | (k1 >>> 17); // ROTL32(k1,15);
+      k1 = this.mul32(k1, c2);
+
+      h1 ^= k1;
+      h1 = ((h1 & 0x7ffff) << 13) | (h1 >>> 19); // ROTL32(h1,13);
+      h1 = (h1 * 5 + 0xe6546b64) | 0;
+    }
+
+    k1 = 0;
+
+    switch (len % 4) {
+      case 3:
+        k1 = (data.charCodeAt(roundedEnd + 2) & 0xff) << 16;
+      // Fallthrough
+      case 2:
+        k1 |= (data.charCodeAt(roundedEnd + 1) & 0xff) << 8;
+      // Fallthrough
+      case 1:
+        k1 |= data.charCodeAt(roundedEnd) & 0xff;
+        k1 = this.mul32(k1, c1);
+        k1 = ((k1 & 0x1ffff) << 15) | (k1 >>> 17); // ROTL32(k1,15);
+        k1 = this.mul32(k1, c2);
+        h1 ^= k1;
+    }
+
+    // Finalization
+    h1 ^= len;
+
+    // Fmix(h1);
+    h1 ^= h1 >>> 16;
+    h1 = this.mul32(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = this.mul32(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+
+    return h1;
+  },
+
+  hashString(data, len, seed) {
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+
+    let h1 = seed;
+    const roundedEnd = len & ~0x1;
+
+    for (let i = 0; i < roundedEnd; i += 2) {
+      var k1 = data.charCodeAt(i) | (data.charCodeAt(i + 1) << 16);
+
+      k1 = this.mul32(k1, c1);
+      k1 = ((k1 & 0x1ffff) << 15) | (k1 >>> 17); // ROTL32(k1,15);
+      k1 = this.mul32(k1, c2);
+
+      h1 ^= k1;
+      h1 = ((h1 & 0x7ffff) << 13) | (h1 >>> 19); // ROTL32(h1,13);
+      h1 = (h1 * 5 + 0xe6546b64) | 0;
+    }
+
+    if (len % 2 == 1) {
+      k1 = data.charCodeAt(roundedEnd);
+      k1 = this.mul32(k1, c1);
+      k1 = ((k1 & 0x1ffff) << 15) | (k1 >>> 17); // ROTL32(k1,15);
+      k1 = this.mul32(k1, c2);
+      h1 ^= k1;
+    }
+
+    // Finalization
+    h1 ^= len << 1;
+
+    // Fmix(h1);
+    h1 ^= h1 >>> 16;
+    h1 = this.mul32(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = this.mul32(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+
+    return h1;
+  },
+};