ewvjs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miukyo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,168 @@
+# ewvjs
+
+**Embedded WebView for JavaScript**
+
+`ewvjs` allows you to create modern desktop applications using Node.js and the Microsoft Edge WebView2 control. It provides a lightweight, native GUI experience with full access to Node.js APIs.
+
+## Features
+
+- 🪟 **Native Window Management**: Create, control, and customize native Windows.
+- 🌐 **Modern Web Technologies**: Build your UI with HTML, CSS, and JavaScript.
+- ⚡ **Node.js Integration**: Call Node.js functions directly from your frontend code.
+- 🖱️ **Context Menus**: Customizable native right-click context menus.
+- 📦 **Packaging**: Built-in CLI tool to package your app into a standalone executable.
+- 🔧 **Native Bindings**: High-performance C# bindings via `node-api-dotnet`.
+- 🖼️ **Customization**: Support for frameless windows, transparency, dark mode, and more.
+
+## Installation
+
+```bash
+npm install ewvjs
+```
+
+## Quick Start
+
+Create a simple application:
+
+```javascript
+const { create_window, start } = require('ewvjs');
+
+// Create a new window
+const win = create_window('My App', 'https://www.google.com', {
+    width: 1024,
+    height: 768,
+    dark_mode: true
+});
+
+// Run the window
+win.run();
+
+// Keep the application alive
+start();
+```
+
+### Exposing Node.js Functions
+
+You can expose Node.js functions to your frontend code easily:
+
+**Backend (Node.js):**
+```javascript
+const { create_window, expose, start } = require('ewvjs');
+const os = require('os');
+
+// Expose a function to specific window or globally
+expose('getSystemInfo', () => {
+    return {
+        platform: os.platform(),
+        arch: os.arch(),
+        cpus: os.cpus().length
+    };
+});
+
+const win = create_window('System Info', 'index.html', { width: 400, height: 300 });
+win.run();
+start();
+```
+
+**Frontend (HTML/JS):**
+```javascript
+// Call the exposed function via window.ewvjs.api
+async function showInfo() {
+    const info = await window.ewvjs.api.getSystemInfo();
+    console.log(info);
+}
+```
+
+## API Reference
+
+### `create_window(title, url, options)`
+
+Creates a new WebView window.
+
+*   `title` (string): The window title.
+*   `url` (string): The URL to load (http/https) or path to a local HTML file or HTML string.
+*   `options` (object): Configuration options.
+
+### Window Options
+
+```typescript
+{
+    title?: string;              // Window title (overrides create_window arg)
+    url?: string;                // URL to load (overrides create_window arg)
+    html?: string;               // HTML content to load directly
+    width?: number;              // Window width
+    height?: number;             // Window height
+    x?: number;                  // X position
+    y?: number;                  // Y position
+    resizable?: boolean;         // Allow resizing
+    fullscreen?: boolean;        // Start in fullscreen
+    hidden?: boolean;            // Start hidden
+    frameless?: boolean;         // Remove window frame
+    focus?: boolean;             // Focus window on creation
+    minimized?: boolean;         // Start minimized
+    maximized?: boolean;         // Start maximized
+    on_top?: boolean;            // Keep window on top
+    confirm_close?: boolean;     // Require confirmation before closing
+    transparent?: boolean;       // Transparent background
+    background_color?: string;   // Hex color (e.g. "#FFFFFF")
+    vibrancy?: boolean;          // Enable window vibrancy/acrylic effect
+    dark_mode?: boolean;         // Enable dark mode
+    title_bar?: boolean;         // Show/hide title bar (if not frameless)
+    icon?: string;               // Path to .ico file
+    session?: {
+        persist?: boolean;       // Persist cookies/localStorage
+        path?: string;           // Custom user data path
+        envname?: string;        // WebView2 Environment name
+    };
+    additional_args?: string;     // Additional WebView2 arguments
+    debug?: boolean;              // Enable debug tools/console
+}
+```
+
+### Window Methods
+
+Once a window is created, you can control it using the returned `Window` instance:
+
+*   **Lifecycle**: `run()`, `close()`, `destroy()`
+*   **State**: `maximize()`, `minimize()`, `restore()`, `show()`, `hide()`, `focus()`, `blur()`
+*   **Size & Position**:
+    *   `getSize()`, `setSize(w, h)`, `resize(w, h)`
+    *   `getPosition()`, `setPosition(x, y)`, `move(x, y)`
+*   **Interaction**:
+    *   `setTitle(title)`
+    *   `navigate(url)`
+    *   `evaluate(script)`: Execute JavaScript in the WebView.
+    *   `setIcon(path)`
+*   **Cookies**: `get_cookies()`, `set_cookie(...)`, `clear_cookies()`
+
+### Custom Context Menus
+
+Define native context menus using `on_context_menu`:
+
+```javascript
+win.on_context_menu = (params) => {
+    return [
+        { label: 'Refresh', click: () => win.reload() },
+        { type: 'separator' },
+        { label: 'Exit', click: () => win.close() }
+    ];
+};
+```
+
+## CLI & Packaging
+
+`ewvjs` comes with a CLI tool to package your application into a standalone executable.
+
+```bash
+npx ewvjs package app.js --output myapp.exe --icon icon.ico
+```
+
+**Options:**
+*   `--output, -o`: Output filename.
+*   `--icon, -i`: Path to application icon (.ico).
+*   `--assets, -a`: Directory of assets to copy.
+*   `--target, -t`: Target platform (default: node18-win-x64).
+
+## License
+
+MIT LICENSE

package/bin/ewvjs-cli.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const path = require('path');
+const fs = require('fs');
+const packageApp = require('../lib/packager');
+const { setIcon } = require('../lib/icon');
+
+const program = new Command();
+
+program
+  .name('ewvjs')
+  .description('CLI tool for packaging ewvjs applications')
+  .version(require('../package.json').version);
+
+program
+  .command('package')
+  .description('Package your ewvjs application into a standalone executable')
+  .argument('<entry>', 'Entry point JavaScript file (e.g., app.js)')
+  .option('-o, --output <name>', 'Output executable name', 'app')
+  .option('-a, --assets <dir>', 'Assets directory to include (e.g., ./assets)', './assets')
+  .option('-i, --icon <file>', 'Application icon (.ico file)')
+  .option('-n, --name <name>', 'Application name', 'My App')
+  .option('-t, --target <target>', 'Target platform', 'node18-win-x64')
+  .option('-m, --modules <modules>', 'Additional node modules to bundle (comma-separated, e.g., "axios,lodash")')
+  .option('--compress', 'Compress the executable with UPX', false)
+  .option('--no-native', 'Skip bundling native DLLs (use if already included)')
+  .action(async (entry, options) => {
+    try {
+      console.log('📦 Packaging ewvjs application...\n');
+      
+      // Validate entry file exists
+      const entryPath = path.resolve(process.cwd(), entry);
+      if (!fs.existsSync(entryPath)) {
+        console.error(`❌ Error: Entry file not found: ${entry}`);
+        process.exit(1);
+      }
+
+      // Validate icon if provided
+      if (options.icon) {
+        const iconPath = path.resolve(process.cwd(), options.icon);
+        if (!fs.existsSync(iconPath)) {
+          console.error(`❌ Error: Icon file not found: ${options.icon}`);
+          process.exit(1);
+        }
+        if (!iconPath.endsWith('.ico')) {
+          console.error('❌ Error: Icon must be a .ico file');
+          process.exit(1);
+        }
+      }
+
+      // Parse additional modules if provided
+      const additionalModules = options.modules 
+        ? options.modules.split(',').map(m => m.trim()).filter(m => m)
+        : [];
+
+      const config = {
+        entry: entryPath,
+        output: options.output,
+        assets: options.assets ? path.resolve(process.cwd(), options.assets) : null,
+        icon: options.icon ? path.resolve(process.cwd(), options.icon) : null,
+        name: options.name,
+        target: options.target,
+        compress: options.compress,
+        includeNative: options.native,
+        additionalModules: additionalModules
+      };
+
+      await packageApp(config);
+
+      console.log('\n✅ Packaging complete!');
+      console.log(`📁 Output: ${path.join(process.cwd(), 'dist', options.output + '.exe')}`);
+      
+    } catch (error) {
+      console.error('\n❌ Packaging failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('init')
+  .description('Initialize a new ewvjs project')
+  .argument('[name]', 'Project name', 'my-ewvjs-app')
+  .action((name) => {
+    const projectDir = path.join(process.cwd(), name);
+    
+    if (fs.existsSync(projectDir)) {
+      console.error(`❌ Error: Directory ${name} already exists`);
+      process.exit(1);
+    }
+
+    console.log(`📂 Creating new ewvjs project: ${name}\n`);
+    
+    // Create directory structure
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, 'assets'), { recursive: true });
+    
+    // Create package.json
+    const packageJson = {
+      name: name,
+      version: '1.0.0',
+      description: 'My ewvjs application',
+      main: 'app.js',
+      scripts: {
+        start: 'node app.js',
+        package: 'ewvjs package app.js -o myapp -n "My App"'
+      },
+      dependencies: {
+        ewvjs: '^1.0.0'
+      }
+    };
+    
+    fs.writeFileSync(
+      path.join(projectDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+    
+    // Create sample app.js
+    const appJs = `const { create_window, start, expose } = require('ewvjs');
+
+expose('greet', (name) => {
+  return \`Hello, \${name}! This is from Node.js 🚀\`;
+});
+
+expose('getSystemInfo', () => {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    uptime: process.uptime()
+  };
+});
+
+// Create main window
+const window = create_window('Hello ewvjs', \`
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Hello ewvjs</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    
+    body {
+      font-family: sans-serif;
+      color: white;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      padding: 20px;
+    }
+    
+    .container {
+      text-align: center;
+      max-width: 600px;
+    }
+    
+    h1 {
+      font-size: 3em;
+      margin-bottom: 20px;
+      text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.2);
+    }
+    
+    p {
+      font-size: 1.2em;
+      margin-bottom: 30px;
+      opacity: 0.9;
+    }
+    
+    input {
+      width: 100%;
+      padding: 15px;
+      font-size: 16px;
+      border: none;
+      margin-bottom: 15px;
+      background: rgba(255, 255, 255, 0.9);
+      color: #333;
+    }
+    
+    button {
+      background: white;
+      color: #000000;
+      border: none;
+      padding: 15px 30px;
+      font-size: 18px;
+      font-weight: bold;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      margin: 5px;
+    }
+    
+    button:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 6px 20px rgba(0, 0, 0, 0.3);
+    }
+    
+    button:active {
+      transform: translateY(0);
+    }
+    
+    .result {
+      margin-top: 20px;
+      padding: 20px;
+      background: rgba(255, 255, 255, 0.15);
+      min-height: 60px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    
+    .info {
+      text-align: left;
+      font-size: 0.9em;
+      line-height: 1.6;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>🚀 Hello ewvjs!</h1>
+    <p>A lightweight WebView2 application for Windows</p>
+    
+    <input type="text" id="nameInput" placeholder="Enter your name..." value="World">
+    
+    <div>
+      <button onclick="sayHello()">Greet Me</button>
+      <button onclick="showSystemInfo()">System Info</button>
+    </div>
+    
+    <div class="result" id="result">
+      Click a button to see the result...
+    </div>
+  </div>
+  
+  <script>
+    async function sayHello() {
+      const name = document.getElementById('nameInput').value || 'World';
+      const result = await window.ewvjs.api.greet(name);
+      document.getElementById('result').innerHTML = '<strong>' + result + '</strong>';
+    }
+    
+    async function showSystemInfo() {
+      const info = await window.ewvjs.api.getSystemInfo();
+      document.getElementById('result').innerHTML = 
+        '<div class="info">' +
+        '<strong>System Information:</strong><br>' +
+        'Platform: ' + info.platform + '<br>' +
+        'Architecture: ' + info.arch + '<br>' +
+        'Node.js: ' + info.nodeVersion + '<br>' +
+        'Uptime: ' + Math.floor(info.uptime) + ' seconds' +
+        '</div>';
+    }
+  </script>
+</body>
+</html>
+\`, {
+  width: 800,
+  height: 600,
+  vibrancy: true,
+  debug: true
+});
+
+window.run();
+
+// Start the event loop
+start();
+`;
+    
+    fs.writeFileSync(path.join(projectDir, 'app.js'), appJs);
+    
+    // Create README
+    const readme = `# ${name}
+
+A ewvjs application.
+
+## Getting Started
+
+1. Install dependencies:
+\`\`\`bash
+npm install
+\`\`\`
+
+2. Run the application:
+\`\`\`bash
+npm start
+\`\`\`
+
+3. Package the application:
+\`\`\`bash
+npm run package
+\`\`\`
+
+## Project Structure
+
+- \`app.js\` - Main application entry point
+- \`assets/\` - Static assets (images, fonts, etc.)
+- \`package.json\` - Project configuration
+
+## Documentation
+
+Visit [ewvjs documentation](https://github.com/your-repo/ewvjs) for more information.
+`;
+    
+    fs.writeFileSync(path.join(projectDir, 'README.md'), readme);
+    
+    console.log('✅ Project created successfully!\n');
+    console.log('Next steps:');
+    console.log(`  cd ${name}`);
+    console.log('  npm install');
+    console.log('  npm start\n');
+  });
+
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types';
+export { WebView } from './webview';
+export { Window } from './window';
+import { WebView } from './webview';
+declare const ewvjs: WebView;
+export default ewvjs;
+export declare const create_window: (title: string, url_or_html?: string, options?: Partial<import("./types").WindowOptions>) => import("./window").Window;
+export declare const start: () => Promise<void>;
+export declare const expose: (name: string, func: Function) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA2BA,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,QAAA,MAAM,KAAK,SAAgB,CAAC;AAC5B,eAAe,KAAK,CAAC;AAGrB,eAAO,MAAM,aAAa,wHAAkC,CAAC;AAC7D,eAAO,MAAM,KAAK,qBAA0B,CAAC;AAC7C,eAAO,MAAM,MAAM,wCAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.start = exports.create_window = exports.Window = exports.WebView = void 0;
+// Setup module resolution for node-api-dotnet BEFORE any imports
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const isPkg = typeof process.pkg !== 'undefined';
+if (isPkg) {
+    const execDir = path.dirname(process.execPath);
+    const dllDir = path.join(execDir, 'native');
+    const nodeModulesPath = path.join(dllDir, 'node_modules');
+    if (fs.existsSync(nodeModulesPath)) {
+        // Set NODE_PATH environment variable
+        const existingNodePath = process.env.NODE_PATH || '';
+        process.env.NODE_PATH = existingNodePath
+            ? `${nodeModulesPath};${existingNodePath}`
+            : nodeModulesPath;
+        // Since pkg locks Module properties, we need to intercept requires at a higher level
+        // Add the node_modules path to require.resolve paths by modifying module.paths
+        // This needs to be done for every module, so we'll hook into the module creation
+        if (typeof require.main !== 'undefined' && require.main.paths) {
+            require.main.paths.unshift(nodeModulesPath);
+        }
+    }
+}
+// Export types
+__exportStar(require("./types"), exports);
+// Export classes
+var webview_1 = require("./webview");
+Object.defineProperty(exports, "WebView", { enumerable: true, get: function () { return webview_1.WebView; } });
+var window_1 = require("./window");
+Object.defineProperty(exports, "Window", { enumerable: true, get: function () { return window_1.Window; } });
+// Create and export singleton instance
+const webview_2 = require("./webview");
+const ewvjs = new webview_2.WebView();
+exports.default = ewvjs;
+// Export convenience functions
+exports.create_window = ewvjs.create_window.bind(ewvjs);
+exports.start = ewvjs.start.bind(ewvjs);
+exports.expose = ewvjs.expose.bind(ewvjs);