ewvjs 1.0.0

package/dist/window.js

@@ -0,0 +1,307 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Window = void 0;
+const utils_1 = require("./utils");
+class Window {
+    constructor(platform, options, exposedFunctions) {
+        this._menuCallbacks = new Map();
+        this.on_context_menu = () => null;
+        this.platform = platform;
+        this.options = Object.assign({}, options);
+        this._exposedFunctions = exposedFunctions;
+        this._closedPromise = new Promise((resolve) => {
+            this._resolveClosed = resolve;
+        });
+        const originalCallback = this.options.jsCallback;
+        this.options.jsCallback = (msg) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._on_message(msg, this._exposedFunctions);
+            if (originalCallback)
+                yield originalCallback(msg);
+            return result;
+        });
+    }
+    get closed() {
+        return this._closedPromise;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.controller = yield this.platform.createWindow(this.options);
+            // Inject exposed functions API
+            const funcList = Object.keys(this._exposedFunctions).map(name => {
+                return { func: name, params: (0, utils_1.getParamNames)(this._exposedFunctions[name]) };
+            });
+            if (funcList.length > 0) {
+                const code = `if (window.ewvjs) { window.ewvjs._createApi(${JSON.stringify(funcList)}); }`;
+                setTimeout(() => this.evaluate_js(code).catch((err) => {
+                    console.error('Failed to inject exposed functions API:', err);
+                }), 500);
+            }
+            return this.controller;
+        });
+    }
+    _call(method_1) {
+        return __awaiter(this, arguments, void 0, function* (method, payload = null) {
+            if (!this.controller || !this.controller[method]) {
+                throw new Error(`Window not running or ${method} not supported`);
+            }
+            const result = this.controller[method](payload);
+            // Check if method returns a Promise (node-api-dotnet JSCallback style)
+            if (result && typeof result.then === 'function') {
+                return result;
+            }
+            else {
+                return result;
+            }
+        });
+    }
+    // Core methods
+    evaluate_js(script) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('evaluate', script);
+        });
+    }
+    evaluate(script) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.evaluate_js(script);
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('close');
+        });
+    }
+    destroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('close');
+        });
+    }
+    // Window state methods
+    maximize() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('maximize'); });
+    }
+    restore() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('restore'); });
+    }
+    minimize() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('minimize'); });
+    }
+    focus() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('focus'); });
+    }
+    blur() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('blur'); });
+    }
+    show() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('show'); });
+    }
+    hide() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('hide'); });
+    }
+    // Size and position methods
+    getSize() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('getSize'); });
+    }
+    setSize(width, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setSize', { width, height });
+        });
+    }
+    resize(width, height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setSize', { width, height });
+        });
+    }
+    getPosition() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('getPosition'); });
+    }
+    setPosition(x, y) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setPosition', { x, y });
+        });
+    }
+    move(x, y) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('move', { x, y });
+        });
+    }
+    get_position() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('getPosition'); });
+    }
+    set_position(x, y) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setPosition', { x, y });
+        });
+    }
+    get_width() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const size = yield this._call('getSize');
+            return size.width;
+        });
+    }
+    get_height() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const size = yield this._call('getSize');
+            return size.height;
+        });
+    }
+    // Title methods
+    setTitle(title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setTitle', title);
+        });
+    }
+    set_title(title) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setTitle', title);
+        });
+    }
+    // Title bar methods
+    show_titlebar() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('setTitleBar', true); });
+    }
+    hide_titlebar() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('setTitleBar', false); });
+    }
+    // Icon methods
+    setIcon(iconPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._call('setIcon', iconPath);
+        });
+    }
+    // Cookie methods
+    get_cookies() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('getCookies'); });
+    }
+    set_cookie(name_1, value_1) {
+        return __awaiter(this, arguments, void 0, function* (name, value, domain = '', path = '/') {
+            return this._call('setCookie', { name, value, domain, path });
+        });
+    }
+    clear_cookies() {
+        return __awaiter(this, void 0, void 0, function* () { return this._call('clearCookies'); });
+    }
+    _on_message(message, exposedFunctions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = typeof message === 'string' ? JSON.parse(message) : message;
+                if (!Array.isArray(data))
+                    return null;
+                const funcName = data[0];
+                const rawParams = data[1];
+                const id = data[2];
+                const params = this._parseParams(rawParams);
+                // Handle special messages
+                if (funcName === 'closed') {
+                    this._resolveClosed();
+                    return null;
+                }
+                if (funcName === 'console') {
+                    console.log('WebView Console:', ...params);
+                    return null;
+                }
+                if (funcName === 'menu_click') {
+                    return this._handleMenuClick(params);
+                }
+                if (funcName === 'context_menu_requested') {
+                    return this._handleContextMenu(params);
+                }
+                // Handle exposed function calls
+                return this._handleExposedFunction(funcName, params, id, exposedFunctions);
+            }
+            catch (e) {
+                return null;
+            }
+        });
+    }
+    _parseParams(rawParams) {
+        let params = [];
+        if (rawParams) {
+            if (typeof rawParams === 'string' && (rawParams.startsWith('[') || rawParams.startsWith('{'))) {
+                try {
+                    const parsed = JSON.parse(rawParams);
+                    params = Array.isArray(parsed) ? parsed : [parsed];
+                }
+                catch (e) {
+                    params = [rawParams];
+                }
+            }
+            else {
+                params = Array.isArray(rawParams) ? rawParams : [rawParams];
+            }
+        }
+        return params;
+    }
+    _handleMenuClick(params) {
+        const callbackId = params[0];
+        const callback = this._menuCallbacks.get(callbackId);
+        if (callback)
+            callback();
+        return null;
+    }
+    _handleContextMenu(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.on_context_menu) {
+                const customMenu = yield this.on_context_menu(params);
+                if (customMenu) {
+                    return this._processMenu(customMenu);
+                }
+            }
+            return null;
+        });
+    }
+    _handleExposedFunction(funcName, params, id, exposedFunctions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const func = exposedFunctions[funcName];
+            if (!func)
+                return null;
+            try {
+                const result = yield func(...params);
+                yield this._sendSuccessResponse(funcName, id, result);
+                return result !== undefined ? result : null;
+            }
+            catch (err) {
+                yield this._sendErrorResponse(funcName, id, err);
+                return null;
+            }
+        });
+    }
+    _sendSuccessResponse(funcName, id, result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resJson = JSON.stringify(result);
+            const code = `window.ewvjs._returnValuesCallbacks["${funcName}"]["${id}"]({value: ${JSON.stringify(resJson)}, isError: false})`;
+            yield this.evaluate_js(code);
+        });
+    }
+    _sendErrorResponse(funcName, id, err) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errObj = { message: err.message, name: err.name, stack: err.stack };
+            const code = `window.ewvjs._returnValuesCallbacks["${funcName}"]["${id}"]({value: ${JSON.stringify(JSON.stringify(errObj))}, isError: true})`;
+            yield this.evaluate_js(code);
+        });
+    }
+    _processMenu(menu) {
+        return menu.map((item) => {
+            const newItem = Object.assign({}, item);
+            if (newItem.click) {
+                const id = newItem.id || (0, utils_1.generateId)();
+                newItem.id = id;
+                this._menuCallbacks.set(id, newItem.click);
+                delete newItem.click;
+            }
+            if (newItem.submenu) {
+                newItem.submenu = this._processMenu(newItem.submenu);
+            }
+            return newItem;
+        });
+    }
+}
+exports.Window = Window;

package/lib/assets.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const path = require('path');
+const archiver = require('archiver');
+
+/**
+ * Bundle assets directory
+ * @param {string} assetsDir - Source assets directory
+ * @param {string} outputDir - Destination directory
+ * @returns {Promise<void>}
+ */
+async function bundleAssets(assetsDir, outputDir) {
+  if (!fs.existsSync(assetsDir)) {
+    throw new Error(`Assets directory not found: ${assetsDir}`);
+  }
+
+  // Create output directory
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Copy assets directory
+  await copyDirectory(assetsDir, outputDir);
+
+  // Get stats
+  const stats = getDirectoryStats(outputDir);
+  console.log(`   Copied ${stats.files} files (${formatBytes(stats.size)})`);
+}
+
+/**
+ * Copy directory recursively
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ */
+async function copyDirectory(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Create a zip archive of assets (alternative to direct copy)
+ * @param {string} assetsDir - Source assets directory
+ * @param {string} outputPath - Output zip file path
+ * @returns {Promise<void>}
+ */
+async function createAssetsArchive(assetsDir, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 } // Maximum compression
+    });
+
+    output.on('close', () => {
+      console.log(`   Created archive: ${formatBytes(archive.pointer())}`);
+      resolve();
+    });
+
+    archive.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.pipe(output);
+    archive.directory(assetsDir, false);
+    archive.finalize();
+  });
+}
+
+/**
+ * Get directory statistics
+ * @param {string} dirPath - Directory path
+ * @returns {{files: number, size: number}}
+ */
+function getDirectoryStats(dirPath) {
+  let fileCount = 0;
+  let totalSize = 0;
+
+  function traverse(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      
+      if (entry.isDirectory()) {
+        traverse(fullPath);
+      } else {
+        fileCount++;
+        totalSize += fs.statSync(fullPath).size;
+      }
+    }
+  }
+
+  traverse(dirPath);
+  return { files: fileCount, size: totalSize };
+}
+
+/**
+ * Format bytes to human-readable string
+ * @param {number} bytes - Number of bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+
+module.exports = {
+  bundleAssets,
+  createAssetsArchive,
+  copyDirectory,
+  formatBytes
+};

package/lib/icon.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+const NtExecutable = require('resedit').NtExecutable;
+const NtExecutableResource = require('resedit').NtExecutableResource;
+const Resource = require('resedit').Resource;
+
+/**
+ * Set icon and metadata for Windows executable
+ * @param {string} exePath - Path to the executable
+ * @param {string} iconPath - Path to the .ico file
+ * @param {string} appName - Application name
+ * @param {Object} options - Additional metadata options
+ * @returns {Promise<void>}
+ */
+async function setIcon(exePath, iconPath, appName, options = {}) {
+  try {
+    // Read the executable
+    const exeBuffer = fs.readFileSync(exePath);
+    const exe = NtExecutable.from(exeBuffer);
+    const res = NtExecutableResource.from(exe);
+
+    // Read the icon file
+    if (iconPath && fs.existsSync(iconPath)) {
+      const iconBuffer = fs.readFileSync(iconPath);
+      
+      // Parse icon data
+      const iconFile = Resource.IconFile.from(iconBuffer);
+      
+      // Replace icon in executable
+      Resource.IconGroupEntry.replaceIconsForResource(
+        res.entries,
+        1, // Icon group ID
+        1033, // Language (English - United States)
+        iconFile.icons.map((icon) => icon.data)
+      );
+      
+      console.log(`   Applied icon: ${path.basename(iconPath)}`);
+    }
+
+    // Set version info
+    const viList = Resource.VersionInfo.fromEntries(res.entries);
+    const vi = viList[0] || Resource.VersionInfo.createEmpty();
+
+    const {
+      version = '1.0.0.0',
+      companyName = '',
+      fileDescription = appName,
+      copyright = `Copyright © ${new Date().getFullYear()}`,
+      productName = appName,
+      internalName = appName.replace(/\s+/g, ''),
+    } = options;
+
+    // Parse version string
+    const [major = 1, minor = 0, patch = 0, build = 0] = version.split('.').map(Number);
+
+    // Set version numbers
+    vi.setFileVersion(major, minor, patch, build, 1033);
+    vi.setProductVersion(major, minor, patch, build, 1033);
+
+    // Set string values
+    vi.setStringValues(
+      { lang: 1033, codepage: 1200 },
+      {
+        ProductName: productName,
+        FileDescription: fileDescription,
+        CompanyName: companyName,
+        LegalCopyright: copyright,
+        FileVersion: version,
+        ProductVersion: version,
+        InternalName: internalName,
+        OriginalFilename: path.basename(exePath)
+      }
+    );
+
+    vi.outputToResourceEntries(res.entries);
+
+    // Write back to executable
+    res.outputResource(exe);
+    const newBuffer = exe.generate();
+    fs.writeFileSync(exePath, Buffer.from(newBuffer));
+
+    console.log(`   Applied metadata: ${appName} v${version}`);
+  } catch (error) {
+    console.warn(`   ⚠ Warning: Could not set icon/metadata: ${error.message}`);
+    console.warn('   The executable was created but icon/metadata may be missing.');
+  }
+}
+
+/**
+ * Validate icon file
+ * @param {string} iconPath - Path to icon file
+ * @returns {boolean}
+ */
+function validateIcon(iconPath) {
+  if (!fs.existsSync(iconPath)) {
+    throw new Error(`Icon file not found: ${iconPath}`);
+  }
+
+  if (!iconPath.toLowerCase().endsWith('.ico')) {
+    throw new Error('Icon file must be in .ico format');
+  }
+
+  const stats = fs.statSync(iconPath);
+  if (stats.size === 0) {
+    throw new Error('Icon file is empty');
+  }
+
+  if (stats.size > 1024 * 1024) {
+    console.warn('Warning: Icon file is larger than 1MB, consider optimizing it');
+  }
+
+  return true;
+}
+
+/**
+ * Extract icon from executable
+ * @param {string} exePath - Path to executable
+ * @param {string} outputPath - Output path for icon file
+ * @returns {Promise<void>}
+ */
+async function extractIcon(exePath, outputPath) {
+  try {
+    const exeBuffer = fs.readFileSync(exePath);
+    const exe = NtExecutable.from(exeBuffer);
+    const res = NtExecutableResource.from(exe);
+
+    // Find icon group
+    const iconGroups = Resource.IconGroupEntry.fromEntries(res.entries);
+    
+    if (iconGroups.length === 0) {
+      throw new Error('No icon found in executable');
+    }
+
+    // Get first icon group
+    const iconGroup = iconGroups[0];
+    const iconFile = Resource.IconFile.from(iconGroup, res.entries);
+
+    // Write icon file
+    fs.writeFileSync(outputPath, Buffer.from(iconFile.data));
+    console.log(`Extracted icon to: ${outputPath}`);
+  } catch (error) {
+    throw new Error(`Failed to extract icon: ${error.message}`);
+  }
+}
+
+module.exports = {
+  setIcon,
+  validateIcon,
+  extractIcon
+};