npm - nanoshell - Versions diffs - 1.7.3 → 1.7.5 - Mend

nanoshell 1.7.3 → 1.7.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/app/app.js +75 -43
package/app/index.html +2 -0
package/cli/index.js +30 -1
package/example_app/app.js +22 -2
package/example_app/index.html +2 -0
package/package.json +15 -6
package/zig-out/bin/cacert.pem +3363 -0
package/zig-out/bin/example_app.exe +0 -0
package/zig-out/bin/icudt67l.dat +0 -0
package/zig-out/bin/nanoshell.exe +0 -0
package/zig-out/bin/resources/cacert.pem +3363 -0
package/zig-out/bin/resources/icudt67l.dat +0 -0
package/SKILL.md +0 -118
package/cli/bundler.zig +0 -128
package/cli/dev_server.zig +0 -192
package/cli/installer.zig +0 -362
package/cli/main.zig +0 -264
package/vendor/bin/AppCore.dll +0 -0
package/vendor/bin/Ultralight.dll +0 -0
package/vendor/bin/UltralightCore.dll +0 -0
package/vendor/bin/WebCore.dll +0 -0
package/vendor/bin/msvcp140.dll +0 -0
package/vendor/bin/vcruntime140.dll +0 -0
package/vendor/bin/vcruntime140_1.dll +0 -0

package/zig-out/bin/resources/icudt67l.dat ADDED Viewed

Binary file

package/SKILL.md DELETED Viewed

@@ -1,118 +0,0 @@
----
-name: nanoshell-desktop-framework
-description: Build ultra-fast, 120 FPS, 17MB RAM native desktop applications using HTML, CSS, JS, and Zig with the NanoShell runtime engine (nanoshell) created by Suman Biswas.
----
-# NanoShell Native Desktop Framework Skill Guide (`nanoshell`)
-**Created & Engineered by Suman Biswas**
-NanoShell is a hyper-lightweight, browser-free native desktop application framework created by Suman Biswas that compiles to a single 3MB executable, boots in < 0.8ms, runs at 120 FPS, and consumes only **17.0 MB RAM**.
----
-## Starter Template Scaffolding Command
-AI agents or developers can scaffold a new application using:
-```bash
-npx nanoshell <app-name>    # Scaffold new app template
-npx nanoshell start         # Launch dev engine
-npx nanoshell build         # Build production release binary only
-npx nanoshell package       # Build binary and generate Windows Inno Setup installer (.exe)
-```
-`npx nanoshell package` generates a Windows Setup `.exe` with a installer dialog allowing end-users to choose:
-- **Per-User Install** (No admin rights required, installs to `%LocalAppData%`)
-- **System-Wide Install** (Requires admin rights, installs to `Program Files`)
----
-## Developer Workflow Guide
-### 1. Project Directory Structure
-```text
-my_nanoshell_app/
-├── assets/
-│   ├── index.html       <-- Standard HTML markup
-│   ├── styles.css       <-- Standard CSS (Flexbox, Grid, Glassmorphism)
-│   └── app.js           <-- Application JavaScript logic
-├── resources/
-│   ├── icudt67l.dat     <-- Unicode ICU data
-│   └── cacert.pem       <-- SSL certificates
-├── build.zig            <-- Zig build script
-├── src/
-│   └── main.zig         <-- NanoShell host runner
-└── bin/
-    └── my_app.exe       <-- Compiled self-contained executable
-```
----
-## 2. Developer HTML & CSS Best Practices
-Developers write standard HTML, CSS, and JS. NanoShell automatically polyfills and optimizes layout rendering at runtime.
-### `assets/index.html`
-```html
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>My NanoShell Native App</title>
-  <link rel="stylesheet" href="styles.css">
-</head>
-<body>
-  <main class="content-area">
-    <header class="glass-card">
-      <h1>My NanoShell App</h1>
-    </header>
-  </main>
-  <script src="app.js"></script>
-</body>
-</html>
-```
-### `assets/styles.css`
-```css
-* {
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-  font-family: 'Segoe UI', sans-serif;
-}
-body {
-  background: #0b0d19;
-  color: #ffffff;
-  height: 100vh;
-  overflow: hidden;
-}
-.content-area {
-  display: flex;
-  flex-direction: column;
-  gap: 24px; /* NanoShell engine auto-polyfills flex gap for WebKit */
-  padding: 32px;
-}
-.glass-card {
-  background: rgba(30, 41, 59, 0.45);
-  border: 1px solid rgba(255, 255, 255, 0.1);
-  border-radius: 16px;
-  padding: 24px;
-}
-```
----
-## 3. How AI Agents Use This Framework
-Any AI agent (Antigravity, Claude, Copilot, ChatGPT) can use this framework by following these rules:
-1. **Scaffold Web Assets in `assets/`**: Put all developer HTML, CSS, and JS in `assets/`. Never hardcode UI elements inside C or Zig source files.
-2. **Standard CSS Rules**: Write standard CSS with `gap`, `display: flex`, and `display: grid`. NanoShell's engine pre-parser handles WebKit layout rules automatically.
-3. **Build via Zig**: Execute `zig build` to bundle DLLs (`Ultralight.dll`, `AppCore.dll`) and deploy assets into `zig-out/bin/`.
-4. **Low Memory Overhead**: NanoShell automatically purges memory caches via `ulPurgeMemory()` and `EmptyWorkingSet()` to maintain 17MB RAM footprint.

package/cli/bundler.zig DELETED Viewed

@@ -1,128 +0,0 @@
-const std = @import("std");
-pub const BundlerConfig = struct {
-    app_name: []const u8 = "ZeroApp",
-    entry_point: []const u8 = "assets/index.html",
-    output_dir: []const u8 = "dist",
-};
-pub const SingleBinaryBundler = struct {
-    allocator: std.mem.Allocator,
-    config: BundlerConfig,
-    pub fn init(allocator: std.mem.Allocator, config: BundlerConfig) SingleBinaryBundler {
-        return .{
-            .allocator = allocator,
-            .config = config,
-        };
-    }
-    pub fn bundle(self: *SingleBinaryBundler) !void {
-        std.log.info("Starting ZeroUI Native App Bundler for '{s}'...", .{self.config.app_name});
-        std.log.info("Packaging Assets -> {s}", .{self.config.entry_point});
-        const io = std.Io.Threaded.global_single_threaded.io();
-        _ = std.Io.Dir.cwd().createDir(io, self.config.output_dir, .default_dir) catch {};
-        var dist_dir = std.Io.Dir.cwd().openDir(io, self.config.output_dir, .{}) catch |err| {
-            std.log.err("Failed to open output dir: {s}", .{@errorName(err)});
-            return err;
-        };
-        _ = dist_dir.createDir(io, "app", .default_dir) catch {};
-        _ = dist_dir.createDir(io, "resources", .default_dir) catch {};
-        const cwd = std.Io.Dir.cwd();
-        // Copy Main Executable (search zig-out/bin, bin, root, example_app.exe)
-        const possible_srcs = [_][]const u8{
-            "zig-out/bin/example_app.exe",
-            "example_app.exe",
-            "bin/example_app.exe",
-            try std.fmt.allocPrint(self.allocator, "bin/{s}.exe", .{self.config.app_name}),
-            try std.fmt.allocPrint(self.allocator, "{s}.exe", .{self.config.app_name}),
-        };
-        const dst_exe_name = try std.fmt.allocPrint(self.allocator, "{s}.exe", .{self.config.app_name});
-        defer self.allocator.free(dst_exe_name);
-        const dst_exe_path = try std.fmt.allocPrint(self.allocator, "{s}/{s}.exe", .{ self.config.output_dir, self.config.app_name });
-        defer self.allocator.free(dst_exe_path);
-        var copied = false;
-        for (possible_srcs) |src| {
-            if (cwd.copyFile(src, dist_dir, dst_exe_name, io, .{})) |_| {
-                copied = true;
-                break;
-            } else |_| {}
-        }
-        if (!copied) {
-            std.log.warn("Executable copy warning: Could not locate baseline executable binary", .{});
-        }
-        // Copy DLLs to dist/ (search vendor/lib, zig-out/bin, and root)
-        const dlls = [_][]const u8{ "AppCore.dll", "Ultralight.dll", "UltralightCore.dll", "WebCore.dll", "vcruntime140.dll", "msvcp140.dll", "vcruntime140_1.dll" };
-        for (dlls) |dll| {
-            const possible_dll_srcs = [_][]const u8{
-                try std.fmt.allocPrint(self.allocator, "vendor/lib/{s}", .{dll}),
-                try std.fmt.allocPrint(self.allocator, "zig-out/bin/{s}", .{dll}),
-                try std.fmt.allocPrint(self.allocator, "bin/{s}", .{dll}),
-                dll,
-            };
-            defer for (possible_dll_srcs) |p| self.allocator.free(p);
-            const dst_dll = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.config.output_dir, dll });
-            defer self.allocator.free(dst_dll);
-            for (possible_dll_srcs) |src_dll| {
-                if (copyFileSimple(src_dll, dst_dll)) {
-                    break;
-                }
-            }
-        }
-        // Copy Resource Files to dist/ and dist/resources/
-        const res_files = [_][]const u8{ "icudt67l.dat", "cacert.pem" };
-        for (res_files) |file| {
-            const possible_res_srcs = [_][]const u8{
-                try std.fmt.allocPrint(self.allocator, "vendor/resources/{s}", .{file}),
-                try std.fmt.allocPrint(self.allocator, "resources/{s}", .{file}),
-                try std.fmt.allocPrint(self.allocator, "zig-out/bin/resources/{s}", .{file}),
-                try std.fmt.allocPrint(self.allocator, "bin/{s}", .{file}),
-            };
-            defer for (possible_res_srcs) |p| self.allocator.free(p);
-            const dst_res1 = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ self.config.output_dir, file });
-            defer self.allocator.free(dst_res1);
-            const dst_res2 = try std.fmt.allocPrint(self.allocator, "{s}/resources/{s}", .{ self.config.output_dir, file });
-            defer self.allocator.free(dst_res2);
-            for (possible_res_srcs) |src_res| {
-                if (copyFileSimple(src_res, dst_res1)) {
-                    _ = copyFileSimple(src_res, dst_res2);
-                    break;
-                }
-            }
-        }
-        // Copy app/* files to dist/app/*
-        var app_dir_opt = cwd.openDir(io, "app", .{ .iterate = true }) catch null;
-        if (app_dir_opt) |*app_dir| {
-            var dist_app_dir = dist_dir.openDir(io, "app", .{}) catch null;
-            if (dist_app_dir) |*dst_app| {
-                var iter = app_dir.iterate();
-                while (iter.next(io) catch null) |entry| {
-                    if (entry.kind == .file) {
-                        _ = app_dir.copyFile(entry.name, dst_app.*, entry.name, io, .{}) catch {};
-                    }
-                }
-            }
-        }
-        std.log.info("Built Custom Named Executable -> '{s}' (Self-contained release package)", .{dst_exe_path});
-    }
-};
-fn copyFileSimple(src: []const u8, dst: []const u8) bool {
-    const io = std.Io.Threaded.global_single_threaded.io();
-    std.Io.Dir.cwd().copyFile(src, std.Io.Dir.cwd(), dst, io, .{}) catch return false;
-    return true;
-}

package/cli/dev_server.zig DELETED Viewed

@@ -1,192 +0,0 @@
-const std = @import("std");
-const installer = @import("installer.zig");
-pub const DevServer = struct {
-    allocator: std.mem.Allocator,
-    pub fn init(allocator: std.mem.Allocator) DevServer {
-        return .{ .allocator = allocator };
-    }
-    pub fn runDevMode(self: *DevServer, app_dir_name: []const u8) !void {
-        _ = app_dir_name;
-        std.log.info("=================================================================", .{});
-        std.log.info("  ⚡ NanoShell Dev Server Started", .{});
-        std.log.info("  Watching app/ directory & nanoshell.json for live changes...", .{});
-        std.log.info("=================================================================", .{});
-        var config = installer.loadConfig(self.allocator) catch installer.AppConfig{};
-        defer config.deinit(self.allocator);
-        // Find executable inside bin/ or zig-out/bin/
-        const io = std.Io.Threaded.global_single_threaded.io();
-        const cwd = std.Io.Dir.cwd();
-        var found_exe: ?[]const u8 = null;
-        const candidate_paths = [_][]const u8{
-            "zig-out/bin/example_app.exe",
-            "bin/example_app.exe",
-            "zig-out/bin/nanoshell.exe",
-        };
-        for (candidate_paths) |p| {
-            if (cwd.openFile(io, p, .{})) |f| {
-                f.close(io);
-                found_exe = p;
-                break;
-            } else |_| {}
-        }
-        if (found_exe == null) {
-            // Search bin/ for any .exe
-            var bin_dir = cwd.openDir(io, "bin", .{ .iterate = true }) catch null;
-            if (bin_dir) |*d| {
-                defer d.close(io);
-                var iter = d.iterate();
-                while (iter.next(io) catch null) |entry| {
-                    if (entry.kind == .file and std.mem.endsWith(u8, entry.name, ".exe")) {
-                        found_exe = try std.fmt.allocPrint(self.allocator, "bin/{s}", .{entry.name});
-                        break;
-                    }
-                }
-            }
-        }
-        var win_exe_buf: [256]u8 = undefined;
-        const exe_to_run = found_exe orelse "bin\\app.exe";
-        var pos: usize = 0;
-        for (exe_to_run) |ch| {
-            if (ch == '/') {
-                win_exe_buf[pos] = '\\';
-            } else {
-                win_exe_buf[pos] = ch;
-            }
-            pos += 1;
-        }
-        win_exe_buf[pos] = 0;
-        const win_path = win_exe_buf[0..pos];
-        var dev_cmd_buf: [300]u8 = undefined;
-        const dev_cmd = std.fmt.bufPrintZ(&dev_cmd_buf, "{s} --dev", .{win_path}) catch win_path;
-        std.log.info("Launching NanoShell runtime in DEV mode: {s}", .{dev_cmd});
-        // Launch app process once - native engine handles smooth in-window hot reload in dev mode
-        var child = try self.spawnChildProcess(dev_cmd);
-        defer _ = child.kill();
-        std.log.info("App running! In-window hot reload active for app/index.html, styles.css, app.js.", .{});
-        const WinApi = struct {
-            pub extern "kernel32" fn Sleep(dwMilliseconds: u32) callconv(.winapi) void;
-            pub extern "kernel32" fn GetExitCodeProcess(hProcess: std.os.windows.HANDLE, lpExitCode: *u32) callconv(.winapi) i32;
-        };
-        var exit_code: u32 = 259; // STILL_ACTIVE
-        while (exit_code == 259) {
-            WinApi.Sleep(500);
-            _ = WinApi.GetExitCodeProcess(child.hProcess, &exit_code);
-        }
-    }
-    fn spawnChildProcess(self: *DevServer, exe_path: []const u8) !ChildProcess {
-        _ = self;
-        var cmd_utf16: [1024]u16 = undefined;
-        const len = try std.unicode.utf8ToUtf16Le(&cmd_utf16, exe_path);
-        cmd_utf16[len] = 0;
-        const STARTUPINFOW = extern struct {
-            cb: u32 = 104,
-            lpReserved: ?[*:0]u16 = null,
-            lpDesktop: ?[*:0]u16 = null,
-            lpTitle: ?[*:0]u16 = null,
-            dwX: u32 = 0,
-            dwY: u32 = 0,
-            dwXSize: u32 = 0,
-            dwYSize: u32 = 0,
-            dwXCountChars: u32 = 0,
-            dwYCountChars: u32 = 0,
-            dwFillAttribute: u32 = 0,
-            dwFlags: u32 = 0,
-            wShowWindow: u16 = 0,
-            cbReserved2: u16 = 0,
-            lpReserved2: ?*u8 = null,
-            hStdInput: ?std.os.windows.HANDLE = null,
-            hStdOutput: ?std.os.windows.HANDLE = null,
-            hStdError: ?std.os.windows.HANDLE = null,
-        };
-        const PROCESS_INFORMATION = extern struct {
-            hProcess: std.os.windows.HANDLE,
-            hThread: std.os.windows.HANDLE,
-            dwProcessId: u32,
-            dwThreadId: u32,
-        };
-        const WinApi = struct {
-            pub extern "kernel32" fn CreateProcessW(
-                lpApplicationName: ?[*:0]const u16,
-                lpCommandLine: ?[*:0]u16,
-                lpProcessAttributes: ?*anyopaque,
-                lpThreadAttributes: ?*anyopaque,
-                bInheritHandles: i32,
-                dwCreationFlags: u32,
-                lpEnvironment: ?*anyopaque,
-                lpCurrentDirectory: ?[*:0]const u16,
-                lpStartupInfo: *const STARTUPINFOW,
-                lpProcessInformation: *PROCESS_INFORMATION,
-            ) callconv(.winapi) i32;
-            pub extern "kernel32" fn TerminateProcess(hProcess: std.os.windows.HANDLE, uExitCode: u32) callconv(.winapi) i32;
-            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) callconv(.winapi) i32;
-        };
-        var si = STARTUPINFOW{};
-        var pi: PROCESS_INFORMATION = undefined;
-        const res = WinApi.CreateProcessW(null, @ptrCast(&cmd_utf16), null, null, 0, 0, null, null, &si, &pi);
-        if (res == 0) return error.ProcessCreationFailed;
-        return ChildProcess{
-            .hProcess = pi.hProcess,
-            .hThread = pi.hThread,
-        };
-    }
-    fn getAppModTime(self: *DevServer) i128 {
-        _ = self;
-        const io = std.Io.Threaded.global_single_threaded.io();
-        const cwd = std.Io.Dir.cwd();
-        var max_mtime: i128 = 0;
-        var app_dir = cwd.openDir(io, "app", .{ .iterate = true }) catch return 0;
-        defer app_dir.close(io);
-        var iter = app_dir.iterate();
-        while (iter.next(io) catch null) |entry| {
-            if (entry.kind == .file) {
-                if (app_dir.statFile(io, entry.name, .{})) |st| {
-                    const ns = st.mtime.toNanoseconds();
-                    if (ns > max_mtime) max_mtime = ns;
-                } else |_| {}
-            }
-        }
-        return max_mtime;
-    }
-};
-pub const ChildProcess = struct {
-    hProcess: std.os.windows.HANDLE,
-    hThread: std.os.windows.HANDLE,
-    pub fn kill(self: *ChildProcess) void {
-        const WinApi = struct {
-            pub extern "kernel32" fn TerminateProcess(hProcess: std.os.windows.HANDLE, uExitCode: u32) callconv(.winapi) i32;
-            pub extern "kernel32" fn CloseHandle(hObject: std.os.windows.HANDLE) callconv(.winapi) i32;
-        };
-        _ = WinApi.TerminateProcess(self.hProcess, 1);
-        _ = WinApi.CloseHandle(self.hProcess);
-        _ = WinApi.CloseHandle(self.hThread);
-    }
-};