haltija 1.1.0

package/dist/client.js

@@ -0,0 +1,387 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/client.ts
+class DevChannelClient {
+  baseUrl;
+  constructor(serverUrl = "http://localhost:8700") {
+    this.baseUrl = serverUrl;
+  }
+  async status() {
+    const res = await fetch(`${this.baseUrl}/status`);
+    return res.json();
+  }
+  async send(channel, action, payload) {
+    const res = await fetch(`${this.baseUrl}/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channel, action, payload })
+    });
+    return res.json();
+  }
+  async request(channel, action, payload, timeout = 5000) {
+    const res = await fetch(`${this.baseUrl}/request`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channel, action, payload, timeout })
+    });
+    return res.json();
+  }
+  async query(selector) {
+    const res = await fetch(`${this.baseUrl}/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, all: false })
+    });
+    const response = await res.json();
+    return response.success ? response.data : null;
+  }
+  async queryAll(selector) {
+    const res = await fetch(`${this.baseUrl}/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, all: true })
+    });
+    const response = await res.json();
+    return response.success ? response.data : [];
+  }
+  async getConsole(since = 0) {
+    const res = await fetch(`${this.baseUrl}/console?since=${since}`);
+    const response = await res.json();
+    return response.success ? response.data : [];
+  }
+  async clearConsole() {
+    await this.request("console", "clear", {});
+  }
+  async eval(code) {
+    const res = await fetch(`${this.baseUrl}/eval`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Eval failed");
+    }
+    return response.data;
+  }
+  async click(selector, options) {
+    const res = await fetch(`${this.baseUrl}/click`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, options })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || `Click failed on ${selector}`);
+    }
+  }
+  async type(selector, text) {
+    const res = await fetch(`${this.baseUrl}/type`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, text })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || `Type failed on ${selector}`);
+    }
+  }
+  async dispatch(event) {
+    const response = await this.request("events", "dispatch", event);
+    if (!response.success) {
+      throw new Error(response.error || "Dispatch failed");
+    }
+  }
+  async focus(selector) {
+    await this.dispatch({ selector, event: "focus" });
+  }
+  async blur(selector) {
+    await this.dispatch({ selector, event: "blur" });
+  }
+  async press(key, modifiers) {
+    await this.dispatch({
+      selector: "body",
+      event: "keydown",
+      options: {
+        key,
+        altKey: modifiers?.alt,
+        ctrlKey: modifiers?.ctrl,
+        metaKey: modifiers?.meta,
+        shiftKey: modifiers?.shift
+      }
+    });
+  }
+  async refresh(hard = false) {
+    const res = await fetch(`${this.baseUrl}/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ hard })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Refresh failed");
+    }
+  }
+  async navigate(url) {
+    const res = await fetch(`${this.baseUrl}/navigate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Navigate failed");
+    }
+  }
+  async getLocation() {
+    const res = await fetch(`${this.baseUrl}/location`);
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Get location failed");
+    }
+    return response.data;
+  }
+  async startRecording(name) {
+    const res = await fetch(`${this.baseUrl}/recording/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Start recording failed");
+    }
+    return response.data.sessionId;
+  }
+  async stopRecording() {
+    const res = await fetch(`${this.baseUrl}/recording/stop`, {
+      method: "POST"
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Stop recording failed");
+    }
+    return response.data;
+  }
+  async replayRecording(session, speed = 1) {
+    const response = await this.request("recording", "replay", { session, speed });
+    if (!response.success) {
+      throw new Error(response.error || "Replay failed");
+    }
+  }
+  async publishBuild(event) {
+    await fetch(`${this.baseUrl}/build`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(event)
+    });
+  }
+  async watchEvents(options) {
+    const response = await this.request("events", "watch", options);
+    if (!response.success) {
+      throw new Error(response.error || "Watch failed");
+    }
+    return response.data.watchId;
+  }
+  async unwatchEvents(watchId) {
+    const response = await this.request("events", "unwatch", { watchId });
+    if (!response.success) {
+      throw new Error(response.error || "Unwatch failed");
+    }
+  }
+  async watchMutations(options) {
+    const res = await fetch(`${this.baseUrl}/mutations/watch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(options || {})
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Watch mutations failed");
+    }
+  }
+  async unwatchMutations() {
+    const res = await fetch(`${this.baseUrl}/mutations/unwatch`, {
+      method: "POST"
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Unwatch mutations failed");
+    }
+  }
+  async getMutationStatus() {
+    const res = await fetch(`${this.baseUrl}/mutations/status`);
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Get mutation status failed");
+    }
+    return response.data;
+  }
+  async getMessages(since = 0) {
+    const res = await fetch(`${this.baseUrl}/messages?since=${since}`);
+    return res.json();
+  }
+  async getInteractiveElements() {
+    const [buttons, links, inputs] = await Promise.all([
+      this.queryAll("button"),
+      this.queryAll("a[href]"),
+      this.queryAll("input, textarea, select")
+    ]);
+    return {
+      buttons: buttons.map((el) => ({
+        selector: el.id ? `#${el.id}` : `button`,
+        text: el.innerText?.slice(0, 50) || ""
+      })),
+      links: links.map((el) => ({
+        selector: el.id ? `#${el.id}` : `a[href="${el.attributes?.href}"]`,
+        text: el.innerText?.slice(0, 50) || "",
+        href: el.attributes?.href || ""
+      })),
+      inputs: inputs.map((el) => ({
+        selector: el.id ? `#${el.id}` : `${el.tagName}[name="${el.attributes?.name}"]`,
+        type: el.attributes?.type,
+        name: el.attributes?.name,
+        placeholder: el.attributes?.placeholder
+      }))
+    };
+  }
+  async getCustomElements() {
+    return this.eval(`
+      Array.from(document.querySelectorAll('*'))
+        .filter(el => el.tagName.includes('-'))
+        .reduce((acc, el) => {
+          const tag = el.tagName.toLowerCase()
+          if (!acc[tag]) acc[tag] = { count: 0, examples: [] }
+          acc[tag].count++
+          if (acc[tag].examples.length < 3) {
+            acc[tag].examples.push({
+              id: el.id || null,
+              classes: el.className?.split?.(' ')?.slice(0, 3) || [],
+              text: el.textContent?.slice(0, 50)
+            })
+          }
+          return acc
+        }, {})
+    `);
+  }
+  async doAndWait(action, options) {
+    const timeout = options?.timeout || 2000;
+    const debounce = options?.debounce || 100;
+    await this.watchMutations({ debounce });
+    const startTime = Date.now();
+    await action();
+    let mutations = [];
+    let lastMutationTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const messages = await this.getMessages(startTime);
+      const newMutations = messages.filter((m) => m.channel === "mutations" && m.action === "batch");
+      if (newMutations.length > mutations.length) {
+        mutations = newMutations;
+        lastMutationTime = Date.now();
+      } else if (mutations.length > 0 && Date.now() - lastMutationTime > debounce * 2) {
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    await this.unwatchMutations();
+    return {
+      mutations,
+      duration: Date.now() - startTime
+    };
+  }
+  async validateTest(test) {
+    const res = await fetch(`${this.baseUrl}/test/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(test)
+    });
+    return res.json();
+  }
+  async runTest(test, options) {
+    const res = await fetch(`${this.baseUrl}/test/run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ test, ...options })
+    });
+    const result = await res.json();
+    return {
+      test,
+      passed: result.passed,
+      startTime: Date.now() - result.duration,
+      endTime: Date.now(),
+      steps: result.steps,
+      error: result.steps.find((s) => !s.passed)?.error
+    };
+  }
+  async runTestSuite(tests, options) {
+    const res = await fetch(`${this.baseUrl}/test/suite`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ tests, ...options })
+    });
+    return res.json();
+  }
+  async loadTest(source) {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      const res = await fetch(source);
+      return res.json();
+    }
+    return JSON.parse(source);
+  }
+  formatTestResult(result) {
+    const lines = [];
+    const icon = result.passed ? "\u2713" : "\u2717";
+    const status = result.passed ? "PASSED" : "FAILED";
+    lines.push(`${icon} ${result.test.name} - ${status}`);
+    lines.push(`  Duration: ${result.endTime - result.startTime}ms`);
+    lines.push("");
+    for (const step of result.steps) {
+      const stepIcon = step.passed ? "  \u2713" : "  \u2717";
+      const desc = step.description || `Step ${step.index + 1}`;
+      lines.push(`${stepIcon} ${desc}`);
+      if (!step.passed && step.error) {
+        lines.push(`      Error: ${step.error}`);
+        if (step.purpose) {
+          lines.push(`      Purpose: ${step.purpose}`);
+        }
+        if (step.context) {
+          lines.push(`      Context: ${JSON.stringify(step.context)}`);
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+}
+var devChannel = new DevChannelClient;
+export {
+  devChannel,
+  DevChannelClient
+};