@mediar-ai/terminator 0.20.6

package/tests/locator-waitfor.test.js

@@ -0,0 +1,286 @@
+const { Desktop } = require("../index.js");
+
+/**
+ * Test for Locator.waitFor() method with 'exists' condition
+ */
+async function testWaitForExists() {
+  console.log("🕐 Testing Locator.waitFor('exists')...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Get any available application for testing
+    const apps = desktop.applications();
+    if (apps.length === 0) {
+      throw new Error("No applications found for testing");
+    }
+
+    const testApp = apps[0];
+    console.log(`📱 Testing with app: ${testApp.name()}`);
+
+    // Test: Wait for a window to exist (should succeed immediately)
+    console.log("Test: Wait for window to exist");
+    const element = await desktop.locator("role:window").waitFor("exists", 5000);
+
+    if (!element) {
+      throw new Error("Expected element to be returned");
+    }
+
+    console.log(`✅ Found window: ${element.name()}`);
+    return true;
+  } catch (error) {
+    console.error("❌ WaitFor exists test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test waitFor() with 'visible' condition
+ */
+async function testWaitForVisible() {
+  console.log("🕐 Testing Locator.waitFor('visible')...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Test: Wait for a visible window
+    console.log("Test: Wait for window to be visible");
+    const element = await desktop.locator("role:window").waitFor("visible", 5000);
+
+    // Check that the element is actually visible
+    if (!element.isVisible()) {
+      throw new Error("Element should be visible");
+    }
+
+    console.log(`✅ Found visible window: ${element.name()}`);
+    return true;
+  } catch (error) {
+    console.error("❌ WaitFor visible test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test waitFor() timeout behavior
+ */
+async function testWaitForTimeout() {
+  console.log("🕐 Testing Locator.waitFor() timeout...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Test: Wait for a non-existent element (should timeout)
+    console.log("Test: Wait for non-existent element (expecting timeout)");
+    let timedOut = false;
+
+    try {
+      await desktop
+        .locator("role:button|ThisButtonDoesNotExist12345XYZ")
+        .waitFor("exists", 1000);
+    } catch (err) {
+      if (err.message.includes("Timed out") || err.message.includes("timeout")) {
+        timedOut = true;
+        console.log("✅ Correctly timed out");
+      } else {
+        throw new Error(`Unexpected error: ${err.message}`);
+      }
+    }
+
+    if (!timedOut) {
+      throw new Error("Expected timeout error");
+    }
+
+    return true;
+  } catch (error) {
+    console.error("❌ WaitFor timeout test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test waitFor() with different conditions
+ */
+async function testWaitForConditions() {
+  console.log("🕐 Testing Locator.waitFor() with different conditions...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Test each condition on a window (which should be visible and enabled)
+    const conditions = ["exists", "visible", "enabled"];
+
+    for (const condition of conditions) {
+      console.log(`Test: waitFor('${condition}')`);
+      const element = await desktop
+        .locator("role:window")
+        .waitFor(condition, 5000);
+
+      if (!element) {
+        throw new Error(`No element returned for condition '${condition}'`);
+      }
+
+      console.log(`✅ Condition '${condition}' met`);
+    }
+
+    return true;
+  } catch (error) {
+    console.error("❌ WaitFor conditions test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test waitFor() with invalid condition
+ */
+async function testWaitForInvalidCondition() {
+  console.log("🕐 Testing Locator.waitFor() with invalid condition...");
+
+  try {
+    const desktop = new Desktop();
+
+    // Test: Invalid condition should throw error
+    console.log("Test: Wait with invalid condition");
+    let errorThrown = false;
+
+    try {
+      await desktop.locator("role:window").waitFor("invalid_condition", 1000);
+    } catch (err) {
+      if (err.message.includes("Invalid condition")) {
+        errorThrown = true;
+        console.log("✅ Correctly rejected invalid condition");
+      } else {
+        throw new Error(`Unexpected error: ${err.message}`);
+      }
+    }
+
+    if (!errorThrown) {
+      throw new Error("Expected error for invalid condition");
+    }
+
+    return true;
+  } catch (error) {
+    console.error("❌ WaitFor invalid condition test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Test waitFor() with chaining
+ */
+async function testWaitForChaining() {
+  console.log("🕐 Testing Locator.waitFor() with chaining...");
+
+  try {
+    const desktop = new Desktop();
+    const apps = desktop.applications();
+
+    if (apps.length === 0) {
+      throw new Error("No applications found for testing");
+    }
+
+    const testApp = apps[0];
+
+    // Test: Wait with chained locator
+    console.log("Test: waitFor with chained locator");
+    const element = await testApp
+      .locator("role:window")
+      .waitFor("visible", 3000);
+
+    console.log(`✅ Found element via chain: ${element.name()}`);
+    return true;
+  } catch (error) {
+    // This might fail if the app has no window, which is acceptable
+    if (error.message.includes("Timed out")) {
+      console.log("ℹ️  No window found in chain (acceptable)");
+      return true;
+    }
+    console.error("❌ WaitFor chaining test failed:", error.message);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runWaitForTests() {
+  console.log("🚀 Starting Locator.waitFor() tests...\n");
+
+  let passed = 0;
+  let total = 0;
+
+  // Test 1: Wait for exists
+  total++;
+  if (await testWaitForExists()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 2: Wait for visible
+  total++;
+  if (await testWaitForVisible()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 3: Timeout behavior
+  total++;
+  if (await testWaitForTimeout()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 4: Different conditions
+  total++;
+  if (await testWaitForConditions()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 5: Invalid condition
+  total++;
+  if (await testWaitForInvalidCondition()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Test 6: Chaining
+  total++;
+  if (await testWaitForChaining()) {
+    passed++;
+  }
+
+  console.log(); // Empty line
+
+  // Results
+  if (passed === total) {
+    console.log(`🎉 All waitFor tests passed! (${passed}/${total})`);
+    process.exit(0);
+  } else {
+    console.log(`❌ Some tests failed: ${passed}/${total} passed`);
+    process.exit(1);
+  }
+}
+
+// Export for use in other test files
+module.exports = {
+  testWaitForExists,
+  testWaitForVisible,
+  testWaitForTimeout,
+  testWaitForConditions,
+  testWaitForInvalidCondition,
+  testWaitForChaining,
+  runWaitForTests,
+};
+
+// Run tests if this file is executed directly
+if (require.main === module) {
+  runWaitForTests().catch((error) => {
+    console.error("💥 Test runner crashed:", error);
+    process.exit(1);
+  });
+}

package/wrapper.d.ts

@@ -0,0 +1,42 @@
+// Re-export all types and interfaces from the original declaration file
+export * from './index.d';
+
+/** Thrown when an element is not found. */
+export class ElementNotFoundError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown when an operation times out. */
+export class TimeoutError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown when permission is denied. */
+export class PermissionDeniedError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown for platform-specific errors. */
+export class PlatformError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown for unsupported operations. */
+export class UnsupportedOperationError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown for unsupported platforms. */
+export class UnsupportedPlatformError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown for invalid arguments. */
+export class InvalidArgumentError extends Error {
+    constructor(message: string);
+}
+
+/** Thrown for internal errors. */
+export class InternalError extends Error {
+    constructor(message: string);
+} 

package/wrapper.js

@@ -0,0 +1,170 @@
+const native = require('./index.js');
+const util = require('util');
+
+function patchInspector(Klass, methodName = 'toString', forcePlainObject = false) {
+  if (!Klass || typeof Klass !== 'function') {
+    console.log('inspect not a function')
+    return;
+  }
+  const proto = Klass.prototype;
+  const original = proto[util.inspect.custom];
+  proto[util.inspect.custom] = function(...args) {
+    if (typeof this[methodName] === 'function') {
+      const result = this[methodName](...args);
+      if (forcePlainObject && result && typeof result === 'object') {
+        return { ...result };
+      }
+      return result;
+    }
+    if (typeof original === 'function') {
+      return original.apply(this, args);
+    }
+    return { ...this };
+  };
+}
+
+function wrapNativeFunction(fn) {
+  if (typeof fn !== 'function') return fn;
+  return function(...args) {
+    try {
+      const result = fn.apply(this, args);
+      if (result instanceof Promise) {
+        return result.catch(error => {
+          throw mapNativeError(error);
+        });
+      }
+      return result;
+    } catch (error) {
+      throw mapNativeError(error);
+    }
+  };
+}
+
+function wrapClassMethods(Class) {
+  const prototype = Class.prototype;
+  const methods = Object.getOwnPropertyNames(prototype);
+  methods.forEach(method => {
+    if (method !== 'constructor' && typeof prototype[method] === 'function') {
+      prototype[method] = wrapNativeFunction(prototype[method]);
+    }
+  });
+  return Class;
+}
+
+function wrapClass(Class, inspectOptions) {
+  const Wrapped = wrapClassMethods(Class);
+  patchInspector(Wrapped, ...(inspectOptions || []));
+  return Wrapped;
+}
+
+// Custom error classes
+class ElementNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ElementNotFoundError';
+    }
+}
+
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+
+class PermissionDeniedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PermissionDeniedError';
+    }
+}
+
+class PlatformError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PlatformError';
+    }
+}
+
+class UnsupportedOperationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnsupportedOperationError';
+    }
+}
+
+class UnsupportedPlatformError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnsupportedPlatformError';
+    }
+}
+
+class InvalidArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidArgumentError';
+    }
+}
+
+class InternalError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InternalError';
+    }
+}
+
+// Error mapping function
+function mapNativeError(error) {
+    if (!error.message) return error;
+    
+    const message = error.message;
+    if (message.startsWith('ELEMENT_NOT_FOUND:')) {
+        return new ElementNotFoundError(message.replace('ELEMENT_NOT_FOUND:', '').trim());
+    }
+    if (message.startsWith('OPERATION_TIMED_OUT:')) {
+        return new TimeoutError(message.replace('OPERATION_TIMED_OUT:', '').trim());
+    }
+    if (message.startsWith('PERMISSION_DENIED:')) {
+        return new PermissionDeniedError(message.replace('PERMISSION_DENIED:', '').trim());
+    }
+    if (message.startsWith('PLATFORM_ERROR:')) {
+        return new PlatformError(message.replace('PLATFORM_ERROR:', '').trim());
+    }
+    if (message.startsWith('UNSUPPORTED_OPERATION:')) {
+        return new UnsupportedOperationError(message.replace('UNSUPPORTED_OPERATION:', '').trim());
+    }
+    if (message.startsWith('UNSUPPORTED_PLATFORM:')) {
+        return new UnsupportedPlatformError(message.replace('UNSUPPORTED_PLATFORM:', '').trim());
+    }
+    if (message.startsWith('INVALID_ARGUMENT:')) {
+        return new InvalidArgumentError(message.replace('INVALID_ARGUMENT:', '').trim());
+    }
+    if (message.startsWith('INTERNAL_ERROR:')) {
+        return new InternalError(message.replace('INTERNAL_ERROR:', '').trim());
+    }
+    return error;
+}
+
+// Wrap the native classes
+const Desktop = wrapClassMethods(native.Desktop);
+const Element = wrapClass(native.Element);
+const Locator = wrapClass(native.Locator);
+const Selector = wrapClass(native.Selector);
+
+// Export everything
+module.exports = {
+    Desktop,
+    Element,
+    Locator,
+    Selector,
+    // Export error classes
+    ElementNotFoundError,
+    TimeoutError,
+    PermissionDeniedError,
+    PlatformError,
+    UnsupportedOperationError,
+    UnsupportedPlatformError,
+    InvalidArgumentError,
+    InternalError
+};