@limrun/ui 0.9.0-rc.8 → 0.13.3-rc.1

package/dist/device-install/index.js

@@ -1,78 +1,572 @@
-import { A as a, O as t, N as i, R as n, P as r, a0 as o, L as l, Z as p, q as c, d, j as g, V as u, S as R, U as D, v as S, M as f, i as m, k as A, Q as v, T as P, e as y, D as C, F as I, f as q, b as B, c as x, a as T, ac as b, $ as h, g as w, a1 as E, a9 as L, aa as F, a6 as U, m as O, a8 as _, l as W, a5 as Y, a4 as k, W as z, af as G, ag as J, ah as M, ad as H, ae as K, C as N, E as V, x as Z, w as j, B as Q, p as X, a7 as $, ab as ee, Y as se, r as ae, _ as te, I as ie, o as ne, X as re, s as oe, K as le, J as pe, G as ce, n as de, h as ge, t as ue, a3 as Re, a2 as De, z as Se, y as fe, u as me, H as Ae } from "../use-device-install-Y42p84we.mjs";
-import { D as Pe, D as ye } from "../device-install-dialog-DgWsZF6o.mjs";
+import { j as ye, n as me, k as ge } from "../browser-storage-BJ__DGJ6.mjs";
+const S = 1, u = 16, s = {
+  DeviceHello: 1,
+  OpenStream: 2,
+  OpenResult: 3,
+  StreamData: 4,
+  StreamClose: 5,
+  InstallProgress: 6,
+  Error: 7,
+  Ping: 8,
+  Pong: 9,
+  StartPairing: 10,
+  StartInstall: 11,
+  PairRecordReady: 12
+};
+function D(e) {
+  const t = new Uint8Array(u + e.payload.byteLength), n = new DataView(t.buffer);
+  return n.setUint8(0, S), n.setUint8(1, e.type), n.setUint8(2, 0), n.setUint8(3, 0), n.setUint32(4, e.requestId), n.setUint32(8, e.streamId), n.setUint32(12, e.payload.byteLength), t.set(e.payload, u), t;
+}
+function A(e) {
+  if (e.byteLength < u)
+    throw new Error(`Relay frame too short: ${e.byteLength}`);
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), n = t.getUint8(0);
+  if (n !== S)
+    throw new Error(`Unsupported relay protocol version ${n}`);
+  const r = t.getUint32(12);
+  if (e.byteLength !== u + r)
+    throw new Error(
+      `Relay frame length mismatch: got ${e.byteLength}, expected ${u + r}`
+    );
+  return {
+    type: t.getUint8(1),
+    requestId: t.getUint32(4),
+    streamId: t.getUint32(8),
+    payload: e.slice(u)
+  };
+}
+function c(e) {
+  return new TextEncoder().encode(JSON.stringify(e));
+}
+function w(e) {
+  return JSON.parse(new TextDecoder().decode(e));
+}
+async function C() {
+  if (!navigator.usb)
+    throw new Error("WebUSB is not available in this browser.");
+  return navigator.usb.requestDevice({ filters: [{ vendorId: 1452 }] });
+}
+function V(e) {
+  const t = [], n = e.configuration?.configurationValue, r = e.configurations.find(
+    (a) => a.configurationValue === n
+  );
+  r && t.push(...b(r));
+  for (const a of e.configurations)
+    a.configurationValue !== n && t.push(...b(a));
+  return t;
+}
+function b(e) {
+  const t = [];
+  for (const n of e.interfaces)
+    for (const r of n.alternates)
+      r.interfaceClass === 255 && r.interfaceSubclass === 254 && r.interfaceProtocol === 2 && t.push({
+        configurationValue: e.configurationValue,
+        interfaceNumber: n.interfaceNumber,
+        alternateSetting: r.alternateSetting,
+        endpoints: r.endpoints
+      });
+  return t;
+}
+async function $(e, t) {
+  e.opened || await e.open(), (!e.configuration || e.configuration.configurationValue !== t.configurationValue) && await e.selectConfiguration(t.configurationValue), await e.claimInterface(t.interfaceNumber), t.alternateSetting !== 0 && await e.selectAlternateInterface(t.interfaceNumber, t.alternateSetting);
+}
+function L(e) {
+  const t = e.endpoints.find(
+    (r) => r.direction === "out" && r.type === "bulk"
+  ), n = e.endpoints.find(
+    (r) => r.direction === "in" && r.type === "bulk"
+  );
+  if (!t || !n)
+    throw new Error("Could not find usbmux bulk endpoints.");
+  return { outEndpoint: t, inEndpoint: n };
+}
+async function v(e, t, n) {
+  const r = await e.transferOut(t.endpointNumber, n);
+  if (r.status !== "ok")
+    throw new Error(`USB transferOut failed: ${r.status}`);
+  n.byteLength % t.packetSize === 0 && await e.transferOut(t.endpointNumber, new Uint8Array());
+}
+async function T(e, t, n = 16384) {
+  const r = await e.transferIn(t.endpointNumber, n);
+  if (r.status !== "ok" || !r.data)
+    throw new Error(`USB transferIn failed: ${r.status}`);
+  return new Uint8Array(r.data.buffer, r.data.byteOffset, r.data.byteLength);
+}
+const R = 0, W = 2, k = 6, B = 4277009102, h = 2, F = 4, f = 16, _ = 49152;
+async function M(e, t) {
+  const { inEndpoint: n, outEndpoint: r } = L(t), a = new Uint8Array(12), i = new DataView(a.buffer);
+  i.setUint32(0, 2), i.setUint32(4, 0), i.setUint32(8, 0), await v(e, r, P(R, a));
+  const o = await I(e, n, 1), l = new DataView(o.payload.buffer, o.payload.byteOffset).getUint32(0), p = {
+    device: e,
+    candidate: t,
+    inEndpoint: n,
+    outEndpoint: r,
+    muxVersion: l,
+    txSeq: 0,
+    rxSeq: 65535,
+    nextSport: _,
+    streams: /* @__PURE__ */ new Map(),
+    writeChain: Promise.resolve(),
+    closed: !1
+  };
+  return l >= 2 && await x(p, W, new Uint8Array([7])), G(p), p;
+}
+async function j(e, t) {
+  if (e.closed)
+    throw new Error("usbmux session is closed.");
+  let n, r;
+  const a = {
+    session: e,
+    sport: e.nextSport++,
+    dport: t,
+    seq: 0,
+    ack: 0,
+    queue: [],
+    waiters: [],
+    opened: new Promise((i, o) => {
+      n = i, r = o;
+    }),
+    resolveOpened: n,
+    rejectOpened: r
+  };
+  return e.streams.set(y(t, a.sport), a), await d(a, h, new Uint8Array()), await a.opened, a;
+}
+async function H(e, t) {
+  if (e.session.closed)
+    throw new Error("usbmux session is closed.");
+  await d(e, f, t), e.seq += t.byteLength;
+}
+async function J(e) {
+  if (e.queue.length > 0)
+    return e.queue.shift();
+  if (e.error)
+    throw e.error;
+  return new Promise((t) => {
+    e.waiters.push(t);
+  });
+}
+function E(e) {
+  e.closed = !0;
+  for (const t of e.streams.values())
+    for (t.error = new Error("usbmux session closed"), t.rejectOpened(t.error); t.waiters.length > 0; )
+      t.waiters.shift()(new Uint8Array());
+  e.streams.clear();
+}
+async function d(e, t, n) {
+  const r = new Uint8Array(20 + n.byteLength), a = new DataView(r.buffer);
+  a.setUint16(0, e.sport), a.setUint16(2, e.dport), a.setUint32(4, e.seq), a.setUint32(8, e.ack), a.setUint8(12, 80), a.setUint8(13, t), a.setUint16(14, 512), r.set(n, 20), await x(e.session, k, r);
+}
+async function x(e, t, n) {
+  if (e.closed)
+    throw new Error("usbmux session is closed.");
+  return e.writeChain = e.writeChain.then(async () => {
+    if (e.closed) return;
+    const r = e.muxVersion >= 2 ? Y(t, n, e.txSeq++, e.rxSeq) : P(t, n);
+    await v(e.device, e.outEndpoint, r);
+  }), e.writeChain;
+}
+async function G(e) {
+  try {
+    for (; ; ) {
+      if (e.closed) return;
+      const t = await I(e.device, e.inEndpoint, e.muxVersion);
+      if (e.closed) return;
+      if (t.rxSeq !== void 0 && (e.rxSeq = t.rxSeq), t.protocol !== k)
+        continue;
+      const n = Q(t.payload), r = e.streams.get(y(n.sport, n.dport));
+      if (r) {
+        if (n.flags & F) {
+          for (r.error = new Error(`Device reset stream ${r.dport}`), r.rejectOpened(r.error); r.waiters.length > 0; )
+            r.waiters.shift()(new Uint8Array());
+          e.streams.delete(y(r.dport, r.sport));
+          continue;
+        }
+        if ((n.flags & (h | f)) === (h | f)) {
+          r.seq += 1, r.ack = n.seq + 1, await d(r, f, new Uint8Array()), r.resolveOpened();
+          continue;
+        }
+        n.payload.byteLength !== 0 && (r.ack = n.seq + n.payload.byteLength, await d(r, f, new Uint8Array()), r.waiters.length > 0 ? r.waiters.shift()(n.payload) : r.queue.push(n.payload));
+      }
+    }
+  } catch {
+    e.closed || E(e);
+  }
+}
+async function I(e, t, n) {
+  for (; ; ) {
+    const r = await T(e, t), a = z(r, n);
+    if (!(n === 1 && a.protocol !== R))
+      return a;
+  }
+}
+function P(e, t) {
+  const n = new Uint8Array(8 + t.byteLength), r = new DataView(n.buffer);
+  return r.setUint32(0, e), r.setUint32(4, n.byteLength), n.set(t, 8), n;
+}
+function Y(e, t, n, r) {
+  const a = new Uint8Array(16 + t.byteLength), i = new DataView(a.buffer);
+  return i.setUint32(0, e), i.setUint32(4, a.byteLength), i.setUint32(8, B), i.setUint16(12, n), i.setUint16(14, r), a.set(t, 16), a;
+}
+function z(e, t) {
+  const n = new DataView(e.buffer, e.byteOffset, e.byteLength), r = n.getUint32(0), a = n.getUint32(4), i = t >= 2 ? 16 : 8;
+  return {
+    protocol: r,
+    length: a,
+    rxSeq: t >= 2 ? n.getUint16(14) : void 0,
+    payload: e.slice(i, a)
+  };
+}
+function Q(e) {
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), n = (t.getUint8(12) >> 4) * 4;
+  return {
+    sport: t.getUint16(0),
+    dport: t.getUint16(2),
+    seq: t.getUint32(4),
+    ack: t.getUint32(8),
+    flags: t.getUint8(13),
+    payload: e.slice(n)
+  };
+}
+function y(e, t) {
+  return `${e}:${t}`;
+}
+class K {
+  constructor(t, n, r, a) {
+    this.webSocketUrl = t, this.session = n, this.deviceHello = r, this.log = a;
+  }
+  socket;
+  streams = /* @__PURE__ */ new Map();
+  frameQueue = Promise.resolve();
+  closed = !1;
+  pairRecordWaiter;
+  async connect() {
+    const t = new WebSocket(this.webSocketUrl);
+    t.binaryType = "arraybuffer", this.socket = t, t.onclose = () => {
+      this.closed = !0, this.log("Relay socket closed"), this.pairRecordWaiter && (this.pairRecordWaiter.reject(new Error("Relay socket closed")), this.pairRecordWaiter = void 0);
+    }, await new Promise((n, r) => {
+      t.onopen = () => n(), t.onerror = () => r(new Error("WebSocket connection failed"));
+    }), t.onmessage = (n) => {
+      const r = n.data instanceof ArrayBuffer ? new Uint8Array(n.data) : new Uint8Array();
+      this.enqueueFrame(r);
+    }, await this.send({
+      type: s.DeviceHello,
+      requestId: 0,
+      streamId: 0,
+      payload: c(this.deviceHello)
+    }), this.log("Connected WebSocket relay");
+  }
+  async startPairing() {
+    const t = new Promise((n, r) => {
+      this.pairRecordWaiter = { resolve: n, reject: r };
+    });
+    return await this.send({
+      type: s.StartPairing,
+      requestId: 0,
+      streamId: 0,
+      payload: c({})
+    }), this.log("Pairing requested"), t;
+  }
+  async startInstall(t) {
+    await this.send({
+      type: s.StartInstall,
+      requestId: 0,
+      streamId: 0,
+      payload: c(t)
+    }), this.log("Installation requested");
+  }
+  close() {
+    this.closed = !0, this.socket?.close();
+  }
+  enqueueFrame(t) {
+    this.frameQueue = this.frameQueue.then(() => this.handleFrame(A(t))).catch((n) => {
+      this.log("Relay frame handling failed", n instanceof Error ? n.message : String(n));
+    });
+  }
+  async handleFrame(t) {
+    switch (t.type) {
+      case s.OpenStream:
+        await this.handleOpenStream(
+          t.requestId,
+          t.streamId,
+          w(t.payload).port
+        );
+        break;
+      case s.StreamData: {
+        const n = this.streams.get(t.streamId);
+        if (!n) throw new Error(`Unknown stream ${t.streamId}`);
+        await H(n, t.payload);
+        break;
+      }
+      case s.StreamClose:
+        this.streams.delete(t.streamId);
+        break;
+      case s.InstallProgress:
+        this.log(X(w(t.payload).message));
+        break;
+      case s.Error:
+        this.handleError(t.payload);
+        break;
+      case s.PairRecordReady:
+        this.handlePairRecordReady(w(t.payload));
+        break;
+      case s.Ping:
+        await this.send({
+          type: s.Pong,
+          requestId: t.requestId,
+          streamId: 0,
+          payload: new Uint8Array()
+        });
+        break;
+    }
+  }
+  handleError(t) {
+    const n = Z(t);
+    this.log("Server error", n), this.pairRecordWaiter && (this.pairRecordWaiter.reject(new Error(n)), this.pairRecordWaiter = void 0);
+  }
+  handlePairRecordReady(t) {
+    this.log("Pair record received", t.udid), this.pairRecordWaiter?.resolve(t), this.pairRecordWaiter = void 0;
+  }
+  async handleOpenStream(t, n, r) {
+    try {
+      const a = await j(this.session, r);
+      this.streams.set(n, a), await this.send({
+        type: s.OpenResult,
+        requestId: t,
+        streamId: n,
+        payload: c({ ok: !0 })
+      }), this.log(`Opened device stream ${n} to port ${r}`), this.pumpDeviceToServer(n, a);
+    } catch (a) {
+      this.log(`Open device stream ${n} failed`, a instanceof Error ? a.message : String(a)), await this.send({
+        type: s.OpenResult,
+        requestId: t,
+        streamId: n,
+        payload: c({
+          ok: !1,
+          error: a instanceof Error ? a.message : String(a)
+        })
+      });
+    }
+  }
+  async pumpDeviceToServer(t, n) {
+    try {
+      for (; ; ) {
+        const r = await J(n);
+        if (this.closed) return;
+        await this.send({
+          type: s.StreamData,
+          requestId: 0,
+          streamId: t,
+          payload: r
+        });
+      }
+    } catch (r) {
+      this.log(`Device stream ${t} closed`, r instanceof Error ? r.message : String(r)), await this.send({
+        type: s.StreamClose,
+        requestId: 0,
+        streamId: t,
+        payload: c({
+          reason: r instanceof Error ? r.message : String(r)
+        })
+      });
+    }
+  }
+  async send(t) {
+    if (!this.closed) {
+      if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+        this.closed = !0;
+        return;
+      }
+      this.socket.send(D(t));
+    }
+  }
+}
+function Z(e) {
+  const t = new TextDecoder().decode(e);
+  try {
+    const n = JSON.parse(t);
+    return U(n.error ?? t);
+  } catch {
+    return U(t);
+  }
+}
+function U(e) {
+  return e.replace(/libimobiledevice/g, "").trim();
+}
+function X(e) {
+  const t = "install status: ";
+  if (!e.startsWith(t))
+    return e;
+  const n = e.slice(t.length), a = new DOMParser().parseFromString(n, "application/xml").querySelector("plist > dict");
+  if (!a)
+    return e;
+  const i = ee(a), o = i.Status ?? "Unknown";
+  return `Install progress: ${i.PercentComplete ? `${i.PercentComplete}% ` : ""}${o}`;
+}
+function ee(e) {
+  const t = {}, n = Array.from(e.children);
+  for (let r = 0; r < n.length; r += 2) {
+    const a = n[r], i = n[r + 1];
+    !a || a.tagName !== "key" || !i || (t[a.textContent ?? ""] = i.textContent ?? "");
+  }
+  return t;
+}
+async function te({ log: e }) {
+  e("Selecting USB device");
+  const t = await C(), n = oe(t);
+  return e(
+    "Selected USB device",
+    `${t.manufacturerName ?? ""} ${t.productName ?? ""} ${t.serialNumber ?? ""}`.trim()
+  ), n;
+}
+async function ne({ limbuildApiUrl: e, token: t, log: n, target: r }) {
+  const a = N(e, t);
+  let i;
+  try {
+    i = await O(a, r, n);
+    const o = await i.startPairing();
+    return { relay: i, pairRecord: o, target: r };
+  } catch (o) {
+    throw i?.close(), o;
+  }
+}
+async function re({
+  limbuildApiUrl: e,
+  token: t,
+  log: n,
+  target: r,
+  pairRecord: a
+}) {
+  const i = N(e, t);
+  let o;
+  try {
+    return o = await O(i, r, n), await o.startInstall(a), o;
+  } catch (l) {
+    throw o?.close(), l;
+  }
+}
+async function ae(e, t) {
+  if (e) {
+    if (e.session && (E(e.session), e.session = void 0), e.claimedInterfaceNumber !== void 0)
+      try {
+        await e.device.releaseInterface(e.claimedInterfaceNumber), t?.("Released usbmux interface");
+      } catch (n) {
+        t?.("USB interface release failed", m(n));
+      } finally {
+        e.claimedInterfaceNumber = void 0;
+      }
+    if (e.device.opened)
+      try {
+        await e.device.close(), t?.("Closed USB device");
+      } catch (n) {
+        t?.("USB device close failed", m(n));
+      }
+  }
+}
+async function O(e, t, n) {
+  await ie(t, n);
+  const r = new K(e, t.session, t.hello, n);
+  return await r.connect(), r;
+}
+async function ie(e, t) {
+  if (!e.session)
+    try {
+      e.candidate = await se(e, t), e.session = await M(e.device, e.candidate), t("Created usbmux session");
+    } catch (n) {
+      throw await ae(e, t), n;
+    }
+}
+function oe(e) {
+  return {
+    device: e,
+    candidate: ce(e),
+    hello: {
+      serialNumber: e.serialNumber,
+      productName: e.productName,
+      manufacturerName: e.manufacturerName,
+      productId: e.productId,
+      vendorId: e.vendorId
+    }
+  };
+}
+async function se(e, t) {
+  const n = q(e.device);
+  if (n.length === 0) throw new Error("No Apple usbmux interface found.");
+  let r;
+  for (const a of n)
+    for (const i of [1, 2])
+      try {
+        return e.device.opened || await e.device.open(), t(
+          "Claiming usbmux interface",
+          `configuration ${a.configurationValue}, interface ${a.interfaceNumber}, alternate ${a.alternateSetting}, attempt ${i}`
+        ), await $(e.device, a), e.claimedInterfaceNumber = a.interfaceNumber, t(
+          "Claimed usbmux interface",
+          `configuration ${a.configurationValue}, interface ${a.interfaceNumber}`
+        ), a;
+      } catch (o) {
+        r = o, t(
+          "USB interface claim failed",
+          `configuration ${a.configurationValue}, interface ${a.interfaceNumber}: ${m(o)}`
+        ), await ue(e), await le(250);
+      }
+  throw r instanceof Error ? r : new Error("Unable to claim any Apple usbmux interface.");
+}
+function ce(e) {
+  const t = q(e)[0];
+  if (!t) throw new Error("No Apple usbmux interface found.");
+  return t;
+}
+function q(e) {
+  const t = V(e), n = e.configuration?.configurationValue;
+  return [
+    ...t.filter((r) => r.configurationValue === n),
+    ...t.filter((r) => r.configurationValue !== n)
+  ];
+}
+function N(e, t) {
+  const n = new URL(e);
+  return n.protocol = n.protocol === "https:" ? "wss:" : "ws:", n.pathname = `${n.pathname.replace(/\/$/, "")}/device/ws`, t && n.searchParams.set("token", t), n.toString();
+}
+function m(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function ue(e) {
+  if (e.claimedInterfaceNumber !== void 0) {
+    try {
+      await e.device.releaseInterface(e.claimedInterfaceNumber);
+    } catch {
+    }
+    e.claimedInterfaceNumber = void 0;
+  }
+  if (e.device.opened)
+    try {
+      await e.device.close();
+    } catch {
+    }
+}
+function le(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+async function fe(e = {}) {
+  return te({ log: e.log ?? g });
+}
+async function de(e) {
+  return ne({ ...e, log: e.log ?? g });
+}
+async function pe(e) {
+  return re({ ...e, log: e.log ?? g });
+}
+function g() {
+}
 export {
-  a as AppleGsaSrpClient,
-  Pe as DeviceInstallDialog,
-  ye as DeviceInstallRelay,
-  t as RELAY_HEADER_BYTES,
-  i as RELAY_PROTOCOL_VERSION,
-  n as RelayClient,
-  r as RelayMessageType,
-  o as claimUsbmux,
-  l as closeDeviceRelayTarget,
-  p as closeUsbmuxSession,
-  c as createAppleRelaySession,
-  d as createBundleIDRequest,
-  g as createDevelopmentProfileRequest,
-  u as createUsbmuxSession,
-  R as decodeFrame,
-  D as decodeJson,
-  S as deleteAppleRelaySession,
-  f as deviceRelayWebSocketUrl,
-  m as downloadCertificateRequest,
-  A as downloadProfileRequest,
-  v as encodeFrame,
-  P as encodeJson,
-  y as exportAppleCertificateP12,
-  C as fetchAppleAccountSession,
-  I as fetchLimbuildInfo,
-  q as findBundleIDRequest,
-  B as findDevelopmentCertificatesRequest,
-  x as findDevelopmentProfilesRequest,
-  T as findDeviceRequest,
-  b as findSigningAssetsForBundle,
-  h as findUsbmuxCandidates,
-  w as generateAppleSigningKeyAndCSR,
-  E as getBulkEndpoints,
-  L as getLatestSigningAssets,
-  F as getLatestSigningAssetsWithCertificate,
-  U as getPairRecord,
-  O as getReusableAppleSigningAssets,
-  _ as getSigningAssets,
-  W as listTeamsRequest,
-  Y as normalizeBundleID,
-  k as normalizeUDID,
-  z as openStream,
-  G as parseProvisioningProfile,
-  J as parseProvisioningProfileBase64,
-  M as parseProvisioningProfileBytes,
-  H as profileContainsDevice,
-  K as profileMatchesBundleID,
-  N as proxyPhoneTwoFactorCode,
-  V as proxyProvisioningRequest,
-  Z as proxySrpComplete,
-  j as proxySrpInit,
-  Q as proxyTwoFactorCode,
-  X as putAppleGeneratedSigningAssets,
-  $ as putPairRecord,
-  ee as putSigningAssets,
-  se as receiveStreamData,
-  ae as registerDeviceRequest,
-  te as requestAppleDevice,
-  ie as requestUSBAccess,
-  ne as selectDeveloperPortalTeam,
-  re as sendStreamData,
-  oe as startBrowserOwnedAppleIDLogin,
-  le as startInstallRelay,
-  pe as startPairingRelay,
-  ce as startSignedDeviceBuild,
-  de as storedSigningAssetsReusable,
-  ge as submitDevelopmentCSRRequest,
-  ue as teamIDCandidates,
-  Re as transferIn,
-  De as transferOutWithZlp,
-  Se as triggerPhoneTwoFactor,
-  fe as triggerTrustedDeviceTwoFactor,
-  me as useDeviceInstall,
-  Ae as watchBuildLogEvents
+  K as RelayClient,
+  ae as closeDeviceRelayTarget,
+  N as deviceRelayWebSocketUrl,
+  ye as getPairRecord,
+  me as normalizeUDID,
+  de as pairDevice,
+  ge as putPairRecord,
+  fe as requestUSBAccess,
+  pe as startDeviceInstall,
+  re as startDeviceInstallRelay,
+  ne as startDevicePairingRelay
 };

package/dist/device-install/react.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../use-device-install-ByUSmeYz.js");exports.useDeviceInstall=e.useDeviceInstall;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("react"),s=require("./index.cjs"),S=require("../browser-storage-C1jQLXat.js");function B({apiUrl:c,token:d,log:e=C}){const[t,h]=r.useState(),[l,y]=r.useState(),[w,u]=r.useState(),[p,n]=r.useState(),[D,v]=r.useState(!1),f=r.useRef(void 0),b=r.useRef(void 0),i=r.useCallback(async()=>{f.current?.close(),f.current=void 0,await s.closeDeviceRelayTarget(b.current,e)},[e]);r.useEffect(()=>{b.current=t},[t]),r.useEffect(()=>()=>{i()},[i]);const m=r.useCallback(async()=>{u("usb"),n(void 0),v(!1);let a;try{await i(),a=await s.requestUSBAccess({log:e});const o=await S.getPairRecord(a.hello.serialNumber);return h(a),y(o),e(o?"Pair record found":"No pair record found",a.hello.serialNumber),a}catch(o){await s.closeDeviceRelayTarget(a,e),h(void 0),y(void 0),n(R(o));return}finally{u(void 0)}},[i,e]),P=r.useCallback(async()=>{if(!c||!t)throw new Error("Select a USB device before pairing.");u("pair"),n(void 0),v(!1);try{await i();const a=await s.pairDevice({limbuildApiUrl:c,token:d,log:e,target:t}),o=await S.putPairRecord(a.pairRecord,{productName:t.hello.productName});return a.relay.close(),await s.closeDeviceRelayTarget(t,e),y(o),v(!1),e("Device paired","The pair record was stored locally in this browser."),o}catch(a){await s.closeDeviceRelayTarget(t,e),v(!0),n(R(a));return}finally{u(void 0)}},[c,i,t,e,d]),q=r.useCallback(async()=>{if(!c||!t||!l)throw new Error("Select and pair a USB device before starting installation.");u("install"),n(void 0);try{return await i(),f.current=await s.startDeviceInstall({limbuildApiUrl:c,token:d,log:e,target:t,pairRecord:l}),e("Device install started","Installation will continue through the connected iPhone."),f.current}catch(a){await s.closeDeviceRelayTarget(t,e),n(R(a));return}finally{u(void 0)}},[c,i,t,e,l,d]),A=r.useCallback(()=>{i(),e("Device relay stopped")},[i,e]);return{device:t,pairRecord:l,busyAction:w,error:p,pairConfirmationRequired:D,hasPairRecord:!!l,canPair:!!c&&!w&&!!t,canInstall:!!c&&!w&&!!t&&!!l,requestUSBAccess:m,pairBrowser:P,startInstallation:q,stopRelay:A,clearError:()=>n(void 0)}}function C(){}function R(c){return c instanceof Error?c.message:String(c)}exports.useDeviceInstallRelay=B;

package/dist/device-install/react.d.ts

@@ -1 +1,23 @@
-export { useDeviceInstall } from '../hooks/use-device-install';
+import { DeviceInstallLog, DeviceRelayTarget, RelayClient, StoredPairRecord } from './index';
+export type DeviceInstallRelayBusyAction = 'usb' | 'pair' | 'install';
+export type UseDeviceInstallRelayOptions = {
+    apiUrl?: string;
+    token?: string;
+    log?: DeviceInstallLog;
+};
+export type UseDeviceInstallRelayResult = {
+    device?: DeviceRelayTarget;
+    pairRecord?: StoredPairRecord;
+    busyAction?: DeviceInstallRelayBusyAction;
+    error?: string;
+    pairConfirmationRequired: boolean;
+    hasPairRecord: boolean;
+    canPair: boolean;
+    canInstall: boolean;
+    requestUSBAccess: () => Promise<DeviceRelayTarget | undefined>;
+    pairBrowser: () => Promise<StoredPairRecord | undefined>;
+    startInstallation: () => Promise<RelayClient | undefined>;
+    stopRelay: () => void;
+    clearError: () => void;
+};
+export declare function useDeviceInstallRelay({ apiUrl, token, log, }: UseDeviceInstallRelayOptions): UseDeviceInstallRelayResult;