windowpp 0.1.1

package/framework/src/AppData/API/AppData.ts

@@ -0,0 +1,137 @@
+export interface AppDataEntry {
+  name: string;
+  path: string;
+  isDir: boolean;
+  isSymlink: boolean;
+}
+
+export interface SeedEntry {
+  relative_path: string;
+  content: string;
+  overwrite?: boolean;
+}
+
+interface PendingCall {
+  resolve: (value: any) => void;
+  reject: (reason: Error) => void;
+}
+
+let callId = 0;
+const pending = new Map<string, PendingCall>();
+
+function getGlobal(): any {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis;
+  return {};
+}
+
+const globalObject = getGlobal();
+const previousResponse = globalObject.__response__;
+
+globalObject.__response__ = function (id: string, result: any, error?: string) {
+  const request = pending.get(id);
+  if (request) {
+    pending.delete(id);
+    if (error) {
+      request.reject(new Error(error));
+    } else {
+      request.resolve(result);
+    }
+    return;
+  }
+
+  if (previousResponse) {
+    previousResponse(id, result, error);
+  }
+};
+
+function invoke<T>(method: string, params: unknown[] = []): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const id = String(++callId);
+    pending.set(id, { resolve, reject });
+    const payload = JSON.stringify({ id, method, params });
+
+    if (globalObject.__native_invoke__) {
+      globalObject.__native_invoke__(payload);
+      return;
+    }
+
+    if (globalObject.chrome?.webview?.postMessage) {
+      globalObject.chrome.webview.postMessage(payload);
+      return;
+    }
+
+    pending.delete(id);
+    reject(new Error('Native bridge not available'));
+  });
+}
+
+export function getRoot(): Promise<string> {
+  return invoke<string>('appData:getRoot');
+}
+
+export function resolve(relative = ''): Promise<string> {
+  return invoke<string>('appData:resolve', [relative]);
+}
+
+export function exists(relative = ''): Promise<boolean> {
+  return invoke<boolean>('appData:exists', [relative]);
+}
+
+export function readText(relative: string): Promise<string> {
+  return invoke<string>('appData:readText', [relative]);
+}
+
+export function writeText(relative: string, content: string): Promise<void> {
+  return invoke<void>('appData:writeText', [relative, content]);
+}
+
+export function appendText(relative: string, content: string): Promise<void> {
+  return invoke<void>('appData:appendText', [relative, content]);
+}
+
+export function deleteFile(relative: string): Promise<void> {
+  return invoke<void>('appData:deleteFile', [relative]);
+}
+
+export function createDir(relative: string, recursive = true): Promise<void> {
+  return invoke<void>('appData:createDir', [relative, recursive]);
+}
+
+export function removeDir(relative: string, recursive = false): Promise<void> {
+  return invoke<void>('appData:removeDir', [relative, recursive]);
+}
+
+export function readDir(relative = ''): Promise<AppDataEntry[]> {
+  return invoke<AppDataEntry[]>('appData:readDir', [relative]);
+}
+
+export function ensureDirs(dirs: string[]): Promise<void> {
+  return invoke<void>('appData:ensureDirs', [dirs]);
+}
+
+export function seedFile(relativePath: string, content: string, overwrite = false): Promise<void> {
+  return invoke<void>('appData:seedFile', [relativePath, content, overwrite]);
+}
+
+export function seedFiles(entries: SeedEntry[]): Promise<void> {
+  return invoke<void>('appData:seedFiles', [entries]);
+}
+
+export const appData = {
+  getRoot,
+  resolve,
+  exists,
+  readText,
+  writeText,
+  appendText,
+  deleteFile,
+  createDir,
+  removeDir,
+  readDir,
+  ensureDirs,
+  seedFile,
+  seedFiles,
+};
+
+export default appData;

package/framework/src/AppData/appdata_bridge.h

@@ -0,0 +1,138 @@
+// ============================================================================
+//  AppData/appdata_bridge.h
+//  Frontend bridge for app-scoped storage rooted in the OS-standard app-data
+//  directory for the current application.
+// ============================================================================
+
+#pragma once
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "appdata_manager.h"
+#include "../FileSystem/filesystem_json.h"
+
+namespace wpp::appdata {
+
+using EvalFn = std::function<void(const std::string& js)>;
+
+class AppDataBridge {
+public:
+    AppDataBridge(EvalFn eval_fn, const std::string& app_name)
+        : eval_(std::move(eval_fn)), manager_(app_name) {}
+
+    void dispatch(const std::string& raw) {
+        std::string id;
+        std::string method;
+        std::vector<wpp::fs::JsonValue> params;
+
+        try {
+            auto env = wpp::fs::JsonValue::parse(raw);
+            id = env["id"].as_string();
+            method = env["method"].as_string();
+            params = env["params"].as_array();
+        } catch (...) {
+            return;
+        }
+
+        if (method.rfind("appData:", 0) != 0) {
+            return;
+        }
+
+        auto reply_ok = [this, &id](const std::string& json_result) {
+            eval_("window.__response__(" + wpp::fs::JsonValue::to_js_argument(id) + "," + json_result + ")");
+        };
+
+        auto reply_err = [this, &id](const std::string& msg) {
+            eval_(
+                "window.__response__(" + wpp::fs::JsonValue::to_js_argument(id) + ",null," +
+                wpp::fs::JsonValue::to_js_argument(msg) + ")");
+        };
+
+        auto relative = [&params](size_t index) -> std::string {
+            if (index >= params.size()) return "";
+            return params[index].as_string();
+        };
+
+        try {
+            if (method == "appData:getRoot") {
+                reply_ok(wpp::fs::JsonValue::dump_value(manager_.root()));
+
+            } else if (method == "appData:resolve") {
+                reply_ok(wpp::fs::JsonValue::dump_value(manager_.path(relative(0))));
+
+            } else if (method == "appData:exists") {
+                reply_ok(manager_.exists(relative(0)) ? "true" : "false");
+
+            } else if (method == "appData:readText") {
+                reply_ok(wpp::fs::JsonValue::dump_value(manager_.read_text(relative(0))));
+
+            } else if (method == "appData:writeText") {
+                manager_.write_text(relative(0), relative(1));
+                reply_ok("null");
+
+            } else if (method == "appData:appendText") {
+                manager_.append_text(relative(0), relative(1));
+                reply_ok("null");
+
+            } else if (method == "appData:deleteFile") {
+                manager_.delete_file(relative(0));
+                reply_ok("null");
+
+            } else if (method == "appData:createDir") {
+                bool recursive = params.size() > 1 && params[1].as_bool();
+                manager_.create_dir(relative(0), recursive);
+                reply_ok("null");
+
+            } else if (method == "appData:removeDir") {
+                bool recursive = params.size() > 1 && params[1].as_bool();
+                manager_.remove_dir(relative(0), recursive);
+                reply_ok("null");
+
+            } else if (method == "appData:readDir") {
+                const auto entries = manager_.read_dir(relative(0));
+                reply_ok(wpp::fs::dirEntriesToJson(entries, &AppDataEntry::is_dir, &AppDataEntry::is_symlink));
+
+            } else if (method == "appData:ensureDirs") {
+                std::vector<std::string> dirs;
+                if (!params.empty()) {
+                    for (const auto& value : params[0].as_array()) {
+                        dirs.push_back(value.as_string());
+                    }
+                }
+                manager_.ensure_dirs(dirs);
+                reply_ok("null");
+
+            } else if (method == "appData:seedFile") {
+                bool overwrite = params.size() > 2 && params[2].as_bool();
+                manager_.seed_file(relative(0), relative(1), overwrite);
+                reply_ok("null");
+
+            } else if (method == "appData:seedFiles") {
+                std::vector<SeedEntry> seeds;
+                if (!params.empty()) {
+                    for (const auto& value : params[0].as_array()) {
+                        seeds.push_back(SeedEntry{
+                            value["relative_path"].as_string(),
+                            value["content"].as_string(),
+                            value.get_bool("overwrite", false)
+                        });
+                    }
+                }
+                manager_.seed_files(seeds);
+                reply_ok("null");
+            }
+        } catch (const std::exception& e) {
+            reply_err(e.what());
+        } catch (...) {
+            reply_err("Unknown error in appData bridge");
+        }
+    }
+
+private:
+    EvalFn eval_;
+    AppDataManager manager_;
+};
+
+} // namespace wpp::appdata

package/framework/src/AppData/appdata_manager.cpp

@@ -0,0 +1,126 @@
+#include "appdata_manager.h"
+#include "../FileSystem/filesystem_handler.h"
+
+#include <filesystem>
+#include <stdexcept>
+
+namespace wpp {
+
+namespace {
+
+std::filesystem::path validate_relative_path(const std::string& relative) {
+    if (relative.empty()) {
+        return {};
+    }
+
+    std::filesystem::path candidate = std::filesystem::path(relative).lexically_normal();
+    if (candidate.empty() || candidate == ".") {
+        return {};
+    }
+
+    if (candidate.is_absolute() || candidate.has_root_name() || candidate.has_root_directory()) {
+        throw std::invalid_argument("AppData path must be relative to the app data root");
+    }
+
+    for (const auto& part : candidate) {
+        if (part == "..") {
+            throw std::invalid_argument("AppData path cannot escape the app data root");
+        }
+    }
+
+    return candidate;
+}
+
+std::string join_under_root(const std::string& root, const std::string& relative) {
+    std::filesystem::path base = std::filesystem::u8path(root);
+    std::filesystem::path rel = validate_relative_path(relative);
+    if (rel.empty()) {
+        return base.u8string();
+    }
+    return (base / rel).lexically_normal().u8string();
+}
+
+} // namespace
+
+AppDataManager::AppDataManager(const std::string& app_name)
+    : root_(paths::app_data_dir(app_name))
+{
+    fs::handleCreateDir(root_, true);
+}
+
+const std::string& AppDataManager::root() const {
+    return root_;
+}
+
+std::string AppDataManager::path(const std::string& relative) const {
+    return join_under_root(root_, relative);
+}
+
+bool AppDataManager::exists(const std::string& relative) const {
+    return fs::handleExists(path(relative));
+}
+
+std::string AppDataManager::read_text(const std::string& relative) const {
+    return fs::handleReadFile(path(relative));
+}
+
+void AppDataManager::write_text(const std::string& relative,
+                                const std::string& content) {
+    std::string full = path(relative);
+    std::filesystem::path parent = std::filesystem::u8path(full).parent_path();
+    if (!parent.empty()) {
+        fs::handleCreateDir(parent.u8string(), true);
+    }
+    fs::handleWriteFile(full, content);
+}
+
+void AppDataManager::append_text(const std::string& relative,
+                                 const std::string& content) {
+    std::string full = path(relative);
+    std::filesystem::path parent = std::filesystem::u8path(full).parent_path();
+    if (!parent.empty()) {
+        fs::handleCreateDir(parent.u8string(), true);
+    }
+    fs::handleAppendFile(full, content);
+}
+
+void AppDataManager::delete_file(const std::string& relative) {
+    fs::handleDeleteFile(path(relative));
+}
+
+void AppDataManager::create_dir(const std::string& relative, bool recursive) {
+    fs::handleCreateDir(path(relative), recursive);
+}
+
+void AppDataManager::remove_dir(const std::string& relative, bool recursive) {
+    fs::handleRemoveDir(path(relative), recursive);
+}
+
+std::vector<AppDataEntry> AppDataManager::read_dir(const std::string& relative) const {
+    std::vector<AppDataEntry> result;
+    for (const auto& entry : fs::handleReadDir(path(relative))) {
+        result.push_back(AppDataEntry{entry.name, entry.path, entry.isDir, entry.isSymlink});
+    }
+    return result;
+}
+
+void AppDataManager::ensure_dirs(const std::vector<std::string>& dirs) {
+    for (const auto& dir : dirs) {
+        create_dir(dir, true);
+    }
+}
+
+void AppDataManager::seed_file(const std::string& relative_path,
+                               const std::string& content,
+                               bool overwrite) {
+    if (!overwrite && exists(relative_path)) return;
+    write_text(relative_path, content);
+}
+
+void AppDataManager::seed_files(const std::vector<SeedEntry>& entries) {
+    for (const auto& entry : entries) {
+        seed_file(entry.relative_path, entry.content, entry.overwrite);
+    }
+}
+
+} // namespace wpp

package/framework/src/AppData/appdata_manager.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <windowpp/windowpp.h>