@vnejs/desktop 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/desktop",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Tools to run desktop app of @vnejs",
   "main": "src/index.js",
   "bin": {

package/src/electron.js

@@ -27,6 +27,9 @@ const createWindow = (options) => {
 };
 
 const runElectron = (options) => {
+  // Allow unmuted <video> autoplay in packaged builds (Steam / Electron).
+  app.commandLine.appendSwitch("autoplay-policy", "no-user-gesture-required");
+
   app.whenReady().then(() => {
     protocol.handle("vnejs", (request) => {
       const url = new URL(request.url);

package/src/server.js

@@ -3,21 +3,37 @@ const os = require("os");
 const fastify = require("fastify");
 const fastifyCors = require("@fastify/cors");
 const fastifyStatic = require("@fastify/static");
-const { readFile, readdir, writeFile, appendFile, mkdir, unlink, access } = require("fs/promises");
+const { readFile, readdir, writeFile, appendFile, mkdir, unlink, rmdir, access } = require("fs/promises");
 const { default: getPort } = require("get-port");
 
-const getPrefix = (key) => {
-  const dot = key.indexOf(".");
+const STORAGE_DEFAULT_GROUP = "_";
 
-  return dot === -1 ? key : key.slice(0, dot);
+const toPosixPath = (value) => value.split(path.sep).join("/");
+
+const getStateRelPath = (key) => {
+  const first = key.indexOf("/");
+
+  if (first === -1) return `${key}.json`;
+
+  const module = key.slice(0, first);
+  const afterModule = key.slice(first + 1);
+  const second = afterModule.indexOf("/");
+
+  if (second === -1) return `${module}.json`;
+
+  const group = afterModule.slice(0, second);
+
+  if (!group || group === STORAGE_DEFAULT_GROUP) return `${module}.json`;
+
+  return toPosixPath(path.join(module, `${group}.json`));
 };
 
-const splitStateByPrefix = (state) =>
+const splitStateByPath = (state) =>
   Object.entries(state).reduce((groups, [key, value]) => {
-    const prefix = getPrefix(key);
+    const relPath = getStateRelPath(key);
 
-    groups[prefix] ??= {};
-    groups[prefix][key] = value;
+    groups[relPath] ??= {};
+    groups[relPath][key] = value;
 
     return groups;
   }, {});
@@ -99,31 +115,75 @@ const runServer = async ({
 
   const ensureStateDir = () => mkdir(resolvedStateDir, { recursive: true });
 
-  const getStateFiles = async () => {
+  const listStateJsonFiles = async (dir = resolvedStateDir) => {
     try {
-      const files = await readdir(resolvedStateDir);
+      const entries = await readdir(dir, { withFileTypes: true });
+      const files = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = path.join(dir, entry.name);
+
+          if (entry.isDirectory()) return listStateJsonFiles(fullPath);
+
+          if (entry.isFile() && entry.name.endsWith(".json")) return [toPosixPath(path.relative(resolvedStateDir, fullPath))];
+
+          return [];
+        }),
+      );
 
-      return files.filter((file) => file.endsWith(".json"));
+      return files.flat();
     } catch {
       return [];
     }
   };
 
+  const removeEmptyStateDirs = async (dir = resolvedStateDir) => {
+    let entries;
+
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+          const fullPath = path.join(dir, entry.name);
+
+          await removeEmptyStateDirs(fullPath);
+
+          try {
+            await rmdir(fullPath);
+          } catch {
+            // directory is not empty
+          }
+        }),
+    );
+  };
+
   const writeStateToDisk = async (state) => {
     await ensureStateDir();
 
-    const groups = splitStateByPrefix(state);
-    const activePrefixes = new Set(Object.keys(groups));
-    const stalePrefixes = (await getStateFiles()).map((file) => file.slice(0, -".json".length)).filter((prefix) => !activePrefixes.has(prefix));
+    const groups = splitStateByPath(state);
+    const activePaths = new Set(Object.keys(groups));
+    const existingPaths = await listStateJsonFiles();
 
     await Promise.all([
-      ...Object.entries(groups).map(([prefix, groupState]) => writeFile(path.join(resolvedStateDir, `${prefix}.json`), JSON.stringify(groupState))),
-      ...stalePrefixes.map((prefix) => unlink(path.join(resolvedStateDir, `${prefix}.json`))),
+      ...Object.entries(groups).map(async ([relPath, groupState]) => {
+        const fullPath = path.join(resolvedStateDir, relPath);
+
+        await mkdir(path.dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, JSON.stringify(groupState));
+      }),
+      ...existingPaths.filter((relPath) => !activePaths.has(relPath)).map((relPath) => unlink(path.join(resolvedStateDir, relPath))),
     ]);
+
+    await removeEmptyStateDirs();
   };
 
   const readStateFromDisk = async () => {
-    const stateFiles = await getStateFiles();
+    const stateFiles = await listStateJsonFiles();
 
     if (!stateFiles.length) return {};