@joystick.js/cli-canary 0.0.0-canary.1

package/src/functions/start/getCodependenciesForFile.js

@@ -0,0 +1,84 @@
+import fs from "fs";
+import readFileDependencyMap from "./readFileDependencyMap.js";
+
+const findCodependenciesInMap = (pathVariations = [], map = {}) => {
+  return Object.entries(map)
+    .filter(([codependentPath, codependentDependencies]) => {
+      const hasMatchingImports =
+        codependentDependencies &&
+        codependentDependencies.imports &&
+        codependentDependencies.imports.some((codependentDependency) => {
+          return pathVariations.some((pathVariation) => {
+            return codependentDependency.path.includes(pathVariation);
+          });
+        });
+
+      const hasMatchingRequires =
+        codependentDependencies &&
+        codependentDependencies.requires &&
+        codependentDependencies.requires.some((codependentDependency) => {
+          return pathVariations.some((pathVariation) => {
+            return codependentDependency.path.includes(pathVariation);
+          });
+        });
+
+      return hasMatchingImports || hasMatchingRequires;
+    })
+    .map(([matchingCodependentPath]) => {
+      return matchingCodependentPath.replace(`${process.cwd()}/`, "");
+    });
+};
+
+const getPathVariations = (path = "") => {
+  const pathParts = path.split("/");
+  const variations = [];
+  const lastPathPart = pathParts && pathParts[pathParts.length - 1];
+
+  pathParts.forEach((pathPart, pathPartIndex) => {
+    let base = `${pathPart}`;
+
+    variations.push(`/${pathPart}`);
+
+    pathParts.slice(pathPartIndex + 1, pathParts.length).forEach((part) => {
+      base = base += `/${part}`;
+      variations.push(base);
+      if (part.includes(".")) {
+        variations.push(base.split(".")[0]);
+      }
+    });
+  });
+
+  if (lastPathPart?.includes('.')) {
+    variations.push(`./${lastPathPart}`);
+    variations.push(`./${lastPathPart?.split('.')[0]}`);
+  }
+
+  variations.push(`./${pathParts[0]}`);
+  variations.push(`./${pathParts[0]}/index`);
+  variations.push(`./${pathParts[0]}/index.js`);
+
+  // TODO: This may wreak havoc eventually, but going to let it slide
+  // for now.
+  variations.push(`/index`);
+  variations.push(`/index.js`);
+
+  return variations;
+};
+
+export default (pathToFind = "") => {
+  const pathVariations = getPathVariations(pathToFind);
+  const fileDependencyMap = readFileDependencyMap();
+  const codpendencies = findCodependenciesInMap(
+    pathVariations,
+    fileDependencyMap
+  );
+
+  return {
+    existing: codpendencies.filter((codependency) => {
+      return !!fs.existsSync(codependency);
+    }),
+    deleted: codpendencies.filter((codependency) => {
+      return !fs.existsSync(codependency);
+    }),
+  };
+};

package/src/functions/start/getFilesToBuild.js

@@ -0,0 +1,49 @@
+import fs from "fs";
+import { join } from "path";
+import masterIgnoreList from "../../lib/masterIgnoreList.js";
+
+const getFileListFromPath = (directoryPath = '', files = []) => {
+  const filesInDirectory = fs.readdirSync(directoryPath);
+  const filesWithDirectoryPathPrefix = filesInDirectory.map((filePathInDirectory = '') => {
+    return join(directoryPath, filePathInDirectory);
+  });
+
+  files.push(...filesWithDirectoryPathPrefix);
+
+  filesWithDirectoryPathPrefix.forEach((filePathWithDirectoryPrefix = '') => {
+    const pathIsDirectory = fs.statSync(filePathWithDirectoryPrefix).isDirectory();
+
+    if (pathIsDirectory) {
+      getFileListFromPath(filePathWithDirectoryPrefix, files);
+    }
+  });
+
+  return files;
+};
+
+
+export default (excludedPaths = [], context = null) => {
+  const files = getFileListFromPath("./");
+  const masterIgnoreListFilteredForContext = context && context === 'start' ? masterIgnoreList?.filter((fileToIgnore) => {
+    return !fileToIgnore.includes('settings');
+  }) : masterIgnoreList;
+
+  const filteredFiles = files
+    .filter((path) => {
+      const isExcluded = excludedPaths.some((excludedPath) => {
+        return path.includes(excludedPath);
+      });
+
+      return !isExcluded;
+    })
+    .filter((path) => {
+      return !masterIgnoreListFilteredForContext.some((excludedPath) => {
+        return path.includes(excludedPath);
+      });
+    })
+    .filter((path) => {
+      return !fs.lstatSync(path).isDirectory();
+    });
+
+  return filteredFiles;
+};

package/src/functions/start/getProcessIdFromPort.js

@@ -0,0 +1,92 @@
+import condense from 'selective-whitespace';
+import netstats from 'netstats';
+
+const platform = process.platform;
+
+function pushTo(target, item) {
+  if (item !== '' && typeof item === 'number' && item !== 0 && target.indexOf(item) === -1) {
+    target.push(item);
+  }
+}
+
+// Example output to parse (macOS):
+// $ lsof -i :8017
+/*
+ COMMAND   PID    USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
+ nc      20661 michael    3u  IPv4 0x3b190d9d07c2c3db      0t0  TCP *:8017 (LISTEN)
+ nc      21145 michael    3u  IPv4 0x3b190d9d054773db      0t0  TCP *:8017 (LISTEN)
+ Python  21221 michael    3u  IPv4 0x3b190d9ceb8dfd7b      0t0  UDP localhost:8017
+ */
+
+// [WIN] $ netstat.exe -a -n -o | findstr :9000
+
+/*
+ TCP    0.0.0.0:9000           0.0.0.0:0              LISTENING       5220
+ TCP    127.0.0.1:9000         127.0.0.1:62376        ESTABLISHED     5220
+ TCP    127.0.0.1:9000         127.0.0.1:62379        ESTABLISHED     5220
+ TCP    127.0.0.1:62288        127.0.0.1:9000         TIME_WAIT       0
+ TCP    127.0.0.1:62299        127.0.0.1:9000         TIME_WAIT       0
+ TCP    127.0.0.1:62376        127.0.0.1:9000         ESTABLISHED     7604
+ TCP    127.0.0.1:62378        127.0.0.1:9000         ESTABLISHED     7604
+ UDP    127.0.0.1:9000         *:*                                    1240
+ */
+
+async function processNetStats(arr) {
+  const pidindex = 1;
+  let items = arr.slice(1);
+
+  if (platform === 'win32') {
+    items = arr;
+  }
+
+  const pids = {
+    all: [],
+    tcp: [],
+    udp: [],
+  };
+
+  await Promise.all(items.map((item) => {
+    const values = condense(item).split(' ');
+    let pid = parseInt(values[pidindex], 10);
+
+    if (platform === 'win32') {
+      pid = parseInt(values.pop(), 10);
+    }
+
+    if (values.length > 1) {
+      if (values.indexOf('TCP') !== -1) {
+        pushTo(pids.tcp, pid);
+        pushTo(pids.all, pid);
+      } else if (values.indexOf('UDP') !== -1) {
+        pushTo(pids.udp, pid);
+        pushTo(pids.all, pid);
+      }
+    }
+
+    return Promise.resolve();
+  }));
+
+  return pids;
+}
+
+function getProcessIdFromPort(port) {
+  if (typeof port !== 'number') {
+    throw new TypeError('Expected a port number');
+  }
+
+  return new Promise(((resolve) => {
+    netstats(port).then((stats) => {
+      processNetStats(stats).then((ps) => {
+        resolve(ps);
+      });
+    }).catch(() => {
+      resolve({
+        all: [],
+        tcp: [],
+        udp: [],
+      });
+    });
+  }));
+}
+
+export default getProcessIdFromPort;

package/src/functions/start/hmrServer.js

@@ -0,0 +1,78 @@
+import fs from "fs";
+import { WebSocketServer } from "ws";
+import generateId from "./generateId";
+
+// NOTE: This doesn't run on the app server (in node). This runs on your local computer
+// as a totally separate process that's forked on joystick start.
+
+export default (() => {
+  const websocketServer = new WebSocketServer({
+    port: parseInt(process.env.PORT, 10) + 1,
+    path: "/_joystick/hmr",
+  });
+
+  process.on("message", (message) => {
+    if (typeof process.HMR_CONNECTIONS === "object") {
+      const parsedMessage = JSON.parse(message);
+      const connections = Object.values(process.HMR_CONNECTIONS);
+      for (let i = 0; i < connections?.length; i += 1) {
+        const connection = connections[i];
+        if (connection?.connection?.send) {
+          connection.connection.send(
+            JSON.stringify({
+              type: "FILE_CHANGE",
+              settings: {
+                global: parsedMessage?.settings?.global,
+                public: parsedMessage?.settings?.public,
+              },
+              indexHTMLChanged: parsedMessage?.indexHTMLChanged,
+            })
+          );
+        }
+      }
+    }
+  });
+
+  websocketServer.on("connection", function connection(websocketConnection) {
+    const connectionId = generateId();
+
+    process.HMR_CONNECTIONS = {
+      ...(process.HMR_CONNECTIONS || {}),
+      [connectionId]: {
+        connection: websocketConnection,
+        watchlist: [],
+      },
+    };
+
+    if (Object.keys(process.HMR_CONNECTIONS || {})?.length > 0) {
+      process.send({ type: "HAS_HMR_CONNECTIONS" });
+    }
+
+    websocketConnection.on("message", (message) => {
+      const parsedMessage = JSON.parse(message);
+
+      if (parsedMessage?.type === "HMR_UPDATE_COMPLETE") {
+        process.send({ type: "HMR_UPDATE_COMPLETED", sessions: parsedMessage?.sessions });
+      }
+
+      if (parsedMessage?.type === "HMR_WATCHLIST") {
+        process.HMR_CONNECTIONS[connectionId]?.watchlist?.push(
+          ...(parsedMessage?.tags || [])
+        );
+      }
+    });
+
+    websocketConnection.on("close", () => {
+      if (process.HMR_CONNECTIONS[connectionId]) {
+        delete process.HMR_CONNECTIONS[connectionId];
+
+        if (Object.keys(process.HMR_CONNECTIONS || {})?.length === 0) {
+          process.send({ type: "HAS_NO_HMR_CONNECTIONS" });
+        }
+      }
+    });
+
+  });
+
+  return true;
+})();