0.9.0

.prettierignore

@@ -3,6 +3,22 @@ build
 dist
 node_modules
 out
-platform/ios
+editor-sample-demo
+
+**/*.cache
 platform/**/editor
-editor-sample-demo
+
+platform/android/studio/.gradle
+platform/android/studio/.idea
+platform/android/studio/app/.cxx
+platform/android/studio/app/build
+platform/android/studio/app/release
+
+platform/docker/package
+
+platform/electron/js
+
+platform/ios/FullStacked.xcarchive
+platform/ios/pkg
+platform/ios/xcode/FullStacked.xcodeproj/xcshareddate
+platform/ios/xcode/FullStacked.xcodeproj/xcuserdata

build.ts

@@ -41,19 +41,6 @@ esbuild.buildSync({
 if (fs.existsSync("editor/build"))
     fs.rmSync("editor/build", { recursive: true });
 
-// old-styles
-const scssFiles = (await scan("editor", fs.promises.readdir as any)).filter(
-    (filePath) => filePath.endsWith(".scss")
-);
-
-const compileScss = async (scssFile: string) => {
-    const { css } = await sass.compileAsync(scssFile);
-    if (css.length) fs.writeFileSync(scssFile.slice(0, -4) + "css", css);
-};
-const compilePromises = scssFiles.map(compileScss);
-await Promise.all(compilePromises);
-// end old-styles
-
 const toBuild = [
     ["editor/index.ts", "index"],
     ["editor/typescript/worker.ts", "worker-ts"]
@@ -78,35 +65,20 @@ for (const [input, output] of toBuild) {
     if (errors) buildErrors.push(errors);
 }
 
-// cleanup
-scssFiles.forEach((scssFile) => {
-    const cssFile = scssFile.slice(0, -4) + "css";
-    if (fs.existsSync(cssFile)) fs.rmSync(cssFile);
-});
-
 if (buildErrors.length) throw buildErrors;
 
 fs.cpSync("editor/index.html", "editor/build/index.html");
 fs.cpSync("editor/assets", "editor/build/assets", {
     recursive: true
 });
 
-// new-ui
-const styleEntrypoint = "editor/new-ui.scss";
+const styleEntrypoint = "editor/index.scss";
 const { css } = await sass.compileAsync(styleEntrypoint);
-await fs.promises.writeFile("editor/build/new-ui.css", css);
+await fs.promises.writeFile("editor/build/index.css", css);
 
-esbuild.buildSync({
-    entryPoints: ["editor/new-ui.ts"],
-    outfile: "editor/build/new-ui.js",
-    bundle: true
-});
-
-await fs.promises.copyFile("editor/new-ui.html", "editor/build/new-ui.html");
 fs.cpSync("editor/icons", "editor/build/icons", {
     recursive: true
 });
-// end new-ui
 
 const sampleDemoDir = "editor-sample-demo";
 if (fs.existsSync(sampleDemoDir)) {
@@ -138,11 +110,16 @@ const branch = child_process
     .toString()
     .trim();
 const commit = child_process.execSync("git rev-parse HEAD").toString().trim();
+const commitNumber = child_process
+    .execSync("git rev-list --count --all")
+    .toString()
+    .trim();
 fs.writeFileSync(
     "editor/build/version.json",
     JSON.stringify({
         version,
         branch,
-        commit
+        commit,
+        commitNumber
     })
 );

editor/api/config/index.ts

@@ -10,10 +10,17 @@ type DATA_TYPE = {
     [CONFIG_TYPE.CONNECTIVITY]: Connectivity;
 };
 
+const configCacheDelay = 2000;
+const configCache: Partial<{
+    [K in keyof DATA_TYPE]: {
+        promise: Promise<DATA_TYPE[K]>;
+        timeout?: ReturnType<typeof setTimeout>;
+    };
+}> = {};
+
 export default {
     async init() {
         const configDir = await rpc().directories.configDirectory();
-
         if (await rpc().fs.exists(configDir, { absolutePath: true })) return;
 
         await rpc().fs.mkdir(configDir, { absolutePath: true });
@@ -30,25 +37,46 @@ export default {
         );
         await git.init(project);
     },
-    async load<T extends CONFIG_TYPE>(type: T): Promise<DATA_TYPE[T] | null> {
-        const configDir = await rpc().directories.configDirectory();
-        const configFile = configDir + "/" + type + ".json";
-        if (
-            (await rpc().fs.exists(configFile, { absolutePath: true }))?.isFile
-        ) {
-            return JSON.parse(
-                (await rpc().fs.readFile(configFile, {
+    load<T extends keyof DATA_TYPE>(type: T): Promise<DATA_TYPE[T]> {
+        if (!configCache[type]) {
+            const promise = new Promise<DATA_TYPE[T]>(async (resolve) => {
+                const configDir = await rpc().directories.configDirectory();
+                const configFile = configDir + "/" + type + ".json";
+
+                const configFileExists = (
+                    await rpc().fs.exists(configFile, { absolutePath: true })
+                )?.isFile;
+                if (!configFileExists) {
+                    return resolve(null);
+                }
+
+                const contents = (await rpc().fs.readFile(configFile, {
                     encoding: "utf8",
                     absolutePath: true
-                })) as string
-            );
+                })) as string;
+
+                resolve(JSON.parse(contents));
+
+                const timeout = setTimeout(() => {
+                    delete configCache[type];
+                }, configCacheDelay);
+
+                if (configCache[type]) {
+                    configCache[type].timeout = timeout;
+                }
+            });
+
+            configCache[type] = {
+                promise
+            } as (typeof configCache)[T];
         }
 
-        return null;
+        return configCache[type].promise;
     },
     async save<T extends CONFIG_TYPE>(type: T, data: DATA_TYPE[T]) {
         const configDir = await rpc().directories.configDirectory();
         const configFile = configDir + "/" + type + ".json";
+        delete configCache[type];
         rpc().fs.writeFile(configFile, JSON.stringify(data, null, 2), {
             absolutePath: true
         });

editor/api/config/types.ts

@@ -31,6 +31,6 @@ export type Connectivity = {
     me: Peer;
     autoConnect: boolean;
     defaultNetworkInterface: string;
-    webAddreses: WebAddress[];
+    webAddresses: WebAddress[];
     peersTrusted: PeerTrusted[];
 };