arcy.js 0.1.0 → 0.1.2

package/dist/chunk-FR6SJSDU.js

@@ -0,0 +1,220 @@
+/* arcy.js — https://arcyai.com */
+
+// src/flow/flow-contract.ts
+var FLOW_GLOBAL = "__arcyFlow";
+var FLOW_CONTRACT = 2;
+
+// src/telemetry/storage.ts
+var NULL_STORE = {
+  getItem: () => null,
+  setItem: () => {
+  },
+  removeItem: () => {
+  }
+};
+function safeStore(raw) {
+  if (!raw) return NULL_STORE;
+  return {
+    getItem(key) {
+      try {
+        return raw.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    setItem(key, value) {
+      try {
+        raw.setItem(key, value);
+      } catch {
+      }
+    },
+    removeItem(key) {
+      try {
+        raw.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+function browserLocalStorage() {
+  try {
+    const candidate = globalThis.localStorage;
+    return safeStore(candidate);
+  } catch {
+    return NULL_STORE;
+  }
+}
+function browserSessionStorage() {
+  try {
+    const candidate = globalThis.sessionStorage;
+    return safeStore(candidate);
+  } catch {
+    return NULL_STORE;
+  }
+}
+function readJson(store, key) {
+  const raw = store.getItem(key);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeJson(store, key, value) {
+  try {
+    store.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+
+// src/flow/preview-state.ts
+var PREVIEW_KEY_PREFIX = "arcy.preview.";
+function isValid(stored) {
+  return typeof stored.flowId === "string" && stored.flowId.length > 0 && typeof stored.currentStepCvid === "string" && stored.currentStepCvid.length > 0 && typeof stored.flowSessionId === "string" && stored.flowSessionId.length > 0 && typeof stored.startedAt === "number" && stored.flow !== void 0 && stored.flow !== null;
+}
+function createPreviewRunState(token, { store: raw = browserSessionStorage() } = {}) {
+  const store = safeStore(raw);
+  const key = PREVIEW_KEY_PREFIX + token;
+  return {
+    read() {
+      const stored = readJson(store, key);
+      if (!stored || !isValid(stored)) return null;
+      return stored;
+    },
+    save(run) {
+      writeJson(store, key, run);
+    },
+    clear() {
+      store.removeItem(key);
+    }
+  };
+}
+function hasPendingPreview(token, store = browserSessionStorage()) {
+  try {
+    return safeStore(store).getItem(PREVIEW_KEY_PREFIX + token) !== null;
+  } catch {
+    return false;
+  }
+}
+
+// src/flow/state.ts
+var FLOW_KEY_PREFIX = "arcy.flow.";
+function isValid2(stored) {
+  return typeof stored.flowId === "string" && stored.flowId.length > 0 && typeof stored.currentStepCvid === "string" && stored.currentStepCvid.length > 0 && typeof stored.flowSessionId === "string" && stored.flowSessionId.length > 0 && typeof stored.startedAt === "number";
+}
+function createFlowRunState(token, { store: raw = browserLocalStorage() } = {}) {
+  const store = safeStore(raw);
+  const key = FLOW_KEY_PREFIX + token;
+  return {
+    read() {
+      const stored = readJson(store, key);
+      if (!stored || !isValid2(stored)) return null;
+      return {
+        flowId: stored.flowId,
+        currentStepCvid: stored.currentStepCvid,
+        flowSessionId: stored.flowSessionId,
+        startedAt: stored.startedAt
+      };
+    },
+    save(run) {
+      writeJson(store, key, run);
+    },
+    clear() {
+      store.removeItem(key);
+    }
+  };
+}
+
+// src/shell/state.ts
+var SHELL_KEY_PREFIX = "arcy.shell.";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var LOCALE_PATTERN = /^[a-z]{2}-[A-Z]{2}$/;
+function readPosition(value) {
+  if (!value || typeof value !== "object") return null;
+  const { x, y } = value;
+  if (typeof x !== "number" || typeof y !== "number") return null;
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  return { x, y };
+}
+function uuidV4(fill) {
+  const source = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (!fill && source && typeof source.randomUUID === "function") {
+    try {
+      const native = source.randomUUID();
+      if (UUID_PATTERN.test(native)) return native;
+    } catch {
+    }
+  }
+  const bytes = new Uint8Array(16);
+  if (fill) {
+    fill(bytes);
+  } else if (source && typeof source.getRandomValues === "function") {
+    source.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += (bytes[i] ?? 0).toString(16).padStart(2, "0");
+  }
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function createShellState(token, { store: raw = browserLocalStorage(), fill } = {}) {
+  const store = safeStore(raw);
+  const key = SHELL_KEY_PREFIX + token;
+  function readRaw() {
+    return readJson(store, key) ?? {};
+  }
+  function patch(next) {
+    writeJson(store, key, { ...readRaw(), ...next });
+  }
+  function read() {
+    const stored = readRaw();
+    const id = stored.anonymousId;
+    return {
+      anonymousId: typeof id === "string" && UUID_PATTERN.test(id) ? id : null,
+      position: readPosition(stored.position),
+      // Anything but a literal `true` means not docked. The value is in the
+      // visitor's own storage, so a truthy string written by an older build
+      // must not be able to hide the widget.
+      docked: stored.docked === true,
+      locale: typeof stored.locale === "string" && LOCALE_PATTERN.test(stored.locale) ? stored.locale : null
+    };
+  }
+  return {
+    read,
+    anonymousId() {
+      const existing = read().anonymousId;
+      if (existing) return existing;
+      patch({ anonymousId: uuidV4(fill) });
+      return read().anonymousId;
+    },
+    rememberPosition(position) {
+      patch({ position });
+    },
+    rememberDocked(docked) {
+      patch({ docked });
+    },
+    rememberLocale(locale) {
+      patch({ locale });
+    },
+    forgetAnonymousId() {
+      const current = readRaw();
+      if (current.anonymousId === void 0) return;
+      delete current.anonymousId;
+      if (Object.keys(current).length === 0) store.removeItem(key);
+      else writeJson(store, key, current);
+    }
+  };
+}
+
+export { FLOW_CONTRACT, FLOW_GLOBAL, browserLocalStorage, browserSessionStorage, createFlowRunState, createPreviewRunState, createShellState, hasPendingPreview, readJson, safeStore, uuidV4, writeJson };

package/dist/chunk-LGWYJSYX.js

@@ -0,0 +1,271 @@
+/* arcy.js — https://arcyai.com */
+
+// src/warn.ts
+function warn(message) {
+  if (typeof console !== "undefined" && console.warn) {
+    console.warn(`[arcy] ${message}`);
+  }
+}
+
+// src/csp.ts
+function readCurrentScriptNonce(doc) {
+  try {
+    const current = doc.currentScript;
+    const own = current?.nonce;
+    if (typeof own === "string" && own.length > 0) return own;
+    const scripts = doc.getElementsByTagName("script");
+    for (let i = 0; i < scripts.length; i++) {
+      const value = scripts[i].nonce;
+      if (typeof value === "string" && value.length > 0) return value;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var captured = typeof document !== "undefined" ? readCurrentScriptNonce(document) : null;
+function currentNonce() {
+  return captured;
+}
+function applyNonce(element) {
+  const nonce = currentNonce();
+  if (!nonce) return;
+  try {
+    ;
+    element.nonce = nonce;
+    element.setAttribute("nonce", nonce);
+  } catch {
+  }
+}
+var CSP_DOCS_URL = "https://docs.arcyai.com/troubleshooting#content-security-policy";
+function originOf(value) {
+  try {
+    const { origin } = new URL(value);
+    return origin && origin !== "null" ? origin : null;
+  } catch {
+    return null;
+  }
+}
+function cspAdvice(options) {
+  const api = originOf(options.apiBase);
+  const cdn = options.cdnBase ? originOf(options.cdnBase) : null;
+  const lines = [
+    "This page's Content-Security-Policy is blocking part of the ARCY widget.",
+    "Add these to the policy your app sends:",
+    ""
+  ];
+  if (cdn) lines.push(`  script-src  ${cdn}`);
+  if (api) {
+    lines.push(`  connect-src ${api}`);
+    lines.push(`  font-src    ${api}`);
+    lines.push(`  img-src     ${api} blob:`);
+  }
+  lines.push("  style-src   'unsafe-inline', or a nonce on the script that loads ARCY");
+  lines.push("");
+  lines.push(
+    "To allow none of them, proxy a path on your own domain to the API and pass it as arcy.init(token, { apiBase })."
+  );
+  lines.push(options.docsUrl ?? CSP_DOCS_URL);
+  return lines.join("\n");
+}
+function reportCspViolations(win, options) {
+  const ours = [options.apiBase, options.cdnBase].filter((value) => typeof value === "string" && value.length > 0).map(originOf).filter((value) => value !== null);
+  let stop = () => {
+  };
+  try {
+    const onViolation = (event) => {
+      const blocked = event.blockedURI;
+      const isOurs = blocked === "inline" || ours.some((origin) => blocked?.startsWith(origin));
+      if (!isOurs) return;
+      stop();
+      warn(cspAdvice(options));
+    };
+    win.document.addEventListener("securitypolicyviolation", onViolation);
+    stop = () => {
+      try {
+        win.document.removeEventListener("securitypolicyviolation", onViolation);
+      } catch {
+      }
+    };
+  } catch {
+  }
+  return () => stop();
+}
+
+// src/shell/host.ts
+var HOST_ID = "arcy-widget";
+var HOST_ATTRIBUTE = "data-arcy";
+var Z_INDEX = "2147483000";
+var CRITICAL_STYLE = [
+  ["position", "fixed"],
+  ["inset", "0"],
+  ["z-index", Z_INDEX],
+  // The layer spans the viewport so the launcher (1.4) and the chat panel (1.5)
+  // share one coordinate space. It must therefore be transparent to the
+  // pointer; each surface inside re-enables its own.
+  ["pointer-events", "none"],
+  // The layer must also be invisible, and that is not the shadow root's job
+  // (D512). The host is in the customer's light DOM whatever happens inside
+  // it, so their `div { background: ... !important }` paints it, and a painted
+  // full-viewport layer is their whole site replaced by a coloured sheet with
+  // no error anywhere. These four are every property that fills or edges a
+  // box, and none of them is something a customer wants on an invisible layer.
+  ["background", "transparent"],
+  ["border", "0"],
+  ["box-shadow", "none"],
+  ["outline", "0"]
+];
+var RESET_STYLE = [
+  ["margin", "0"],
+  ["padding", "0"]
+];
+var STYLE_MARKER = "data-arcy-style";
+var shells = /* @__PURE__ */ new Map();
+function isMounted(id = HOST_ID) {
+  const shell = shells.get(id);
+  return shell !== void 0 && shell.host.isConnected;
+}
+function createShell(options = {}) {
+  if (typeof document === "undefined") return null;
+  const id = options.id ?? HOST_ID;
+  const container = options.container;
+  if (isMounted(id)) {
+    warn("This ARCY surface is already on this page. Ignoring the second mount.");
+    return null;
+  }
+  shells.delete(id);
+  const parent = container ?? document.body ?? document.documentElement;
+  if (!parent) {
+    warn("The page has no <body> to mount into yet. The widget will not render.");
+    return null;
+  }
+  if (!container) {
+    const hosts = document.querySelectorAll(`[${HOST_ATTRIBUTE}]`);
+    for (let i = 0; i < hosts.length; i += 1) {
+      if (hosts[i]?.id === id) {
+        warn("Another copy of ARCY is already on this page. Ignoring this one.");
+        return null;
+      }
+    }
+  }
+  try {
+    const host = document.createElement("div");
+    host.id = id;
+    host.setAttribute(HOST_ATTRIBUTE, "");
+    for (const [property, value] of CRITICAL_STYLE) {
+      host.style.setProperty(property, value, "important");
+    }
+    for (const [property, value] of RESET_STYLE) {
+      host.style.setProperty(property, value);
+    }
+    let root = host;
+    let isolated = false;
+    try {
+      if (host.attachShadow) {
+        root = host.attachShadow({ mode: "closed" });
+        isolated = true;
+      }
+    } catch {
+    }
+    parent.appendChild(host);
+    isolateInteractions(host);
+    const shell = {
+      host,
+      root,
+      isolated,
+      destroy() {
+        try {
+          if (host.parentNode) host.parentNode.removeChild(host);
+        } catch {
+        }
+        if (shells.get(id) === shell) shells.delete(id);
+      }
+    };
+    shells.set(id, shell);
+    return shell;
+  } catch (error) {
+    warn(`The widget could not mount. ${String(error)}`);
+    return null;
+  }
+}
+var ISOLATED_EVENTS = [
+  "pointerdown",
+  "pointerup",
+  "pointercancel",
+  "mousedown",
+  "mouseup",
+  "click",
+  "dblclick",
+  "auxclick",
+  "contextmenu",
+  "touchstart",
+  "touchend",
+  "touchcancel",
+  "focusin",
+  "focusout",
+  "keydown",
+  "keyup",
+  "keypress",
+  "beforeinput",
+  "input",
+  "change",
+  "compositionstart",
+  "compositionupdate",
+  "compositionend",
+  "cut",
+  "copy",
+  "paste"
+];
+function isolateInteractions(host) {
+  const stop = (event) => {
+    try {
+      event.stopPropagation();
+    } catch {
+    }
+  };
+  for (const type of ISOLATED_EVENTS) {
+    try {
+      host.addEventListener(type, stop);
+    } catch {
+    }
+  }
+  try {
+    host.addEventListener("mousedown", (event) => {
+      if (event.defaultPrevented) return;
+      releaseHostFocus(host.ownerDocument, host);
+    });
+  } catch {
+  }
+}
+function releaseHostFocus(doc, host) {
+  try {
+    const active = doc.activeElement;
+    if (!active || active === host || host.contains(active)) return;
+    if (active === doc.body || active === doc.documentElement) return;
+    const blur = active.blur;
+    if (typeof blur === "function") blur.call(active);
+  } catch {
+  }
+}
+function injectStyles(shell, css) {
+  if (!shell.isolated) return false;
+  try {
+    const existing = shell.root.querySelector(`[${STYLE_MARKER}]`);
+    if (existing) {
+      existing.textContent = `${existing.textContent ?? ""}
+${css}`;
+      return true;
+    }
+    const style = shell.host.ownerDocument.createElement("style");
+    applyNonce(style);
+    style.setAttribute(STYLE_MARKER, "");
+    style.textContent = css;
+    shell.root.appendChild(style);
+    return true;
+  } catch (error) {
+    warn(`The widget could not apply its styles. ${String(error)}`);
+    return false;
+  }
+}
+
+export { HOST_ATTRIBUTE, Z_INDEX, applyNonce, createShell, injectStyles, releaseHostFocus, reportCspViolations, warn };

package/dist/chunk-NIHUDSWK.js

@@ -0,0 +1,155 @@
+import { querySelectorAllDeep, captureEventFingerprint, containsAcrossShadow, collectElementsDeep, isInteractive, MASK } from './chunk-NY3NXM2V.js';
+
+/* arcy.js — https://arcyai.com */
+
+// src/fingerprint/matcher.ts
+function isVisible(el) {
+  return el.getClientRects().length > 0;
+}
+var WEIGHT_TEST_ID = 50;
+var WEIGHT_TEXT = 40;
+var WEIGHT_TEXT_DYNAMIC = 10;
+var WEIGHT_ARIA_LABEL = 15;
+var WEIGHT_ID = 15;
+var WEIGHT_TAG = 10;
+var WEIGHT_PLACEHOLDER = 10;
+var WEIGHT_ANCESTOR = 10;
+var WEIGHT_ROLE = 5;
+var WEIGHT_SIBLING_INDEX = 5;
+var TEXT_CONTAINMENT_CREDIT = 0.6;
+var ANCESTOR_PARTIAL_CREDIT = 0.7;
+var PRECISION_THRESHOLDS = {
+  1: 0.3,
+  2: 0.45,
+  3: 0.6,
+  4: 0.75,
+  5: 0.9
+};
+function demask(value) {
+  return value.split(MASK).join(" ").replace(/\s+/g, " ").trim();
+}
+function textSignal(stored, live) {
+  if (live === void 0) return 0;
+  const storedText = demask(stored);
+  const liveText = demask(live);
+  if (storedText === "" || liveText === "") return 0;
+  if (liveText === storedText) return 1;
+  if (liveText.includes(storedText) || storedText.includes(liveText))
+    return TEXT_CONTAINMENT_CREDIT;
+  return 0;
+}
+function exactSignal(stored, live) {
+  return live === stored ? 1 : 0;
+}
+function isMaskOnly(value) {
+  return value.includes(MASK) && demask(value) === "";
+}
+function scoreFingerprint(stored, live, dynamicText) {
+  let weightSum = 0;
+  let scoreSum = 0;
+  const add = (weight, signal) => {
+    weightSum += weight;
+    scoreSum += weight * signal;
+  };
+  if (stored.testId !== void 0)
+    add(WEIGHT_TEST_ID, exactSignal(stored.testId, live.testId));
+  if (stored.text !== void 0 && demask(stored.text) !== "") {
+    add(
+      dynamicText ? WEIGHT_TEXT_DYNAMIC : WEIGHT_TEXT,
+      textSignal(stored.text, live.text)
+    );
+  }
+  if (stored.ariaLabel !== void 0 && !isMaskOnly(stored.ariaLabel))
+    add(WEIGHT_ARIA_LABEL, exactSignal(stored.ariaLabel, live.ariaLabel));
+  if (stored.placeholder !== void 0 && !isMaskOnly(stored.placeholder)) {
+    add(WEIGHT_PLACEHOLDER, exactSignal(stored.placeholder, live.placeholder));
+  }
+  if (stored.id !== void 0) add(WEIGHT_ID, exactSignal(stored.id, live.id));
+  if (stored.role !== void 0)
+    add(WEIGHT_ROLE, exactSignal(stored.role, live.role));
+  add(WEIGHT_TAG, live.tag === stored.tag ? 1 : 0);
+  add(WEIGHT_SIBLING_INDEX, live.siblingIndex === stored.siblingIndex ? 1 : 0);
+  if (stored.ancestorAttr !== void 0 && stored.ancestorValue !== void 0 && !isMaskOnly(stored.ancestorValue)) {
+    let signal = 0;
+    if (live.ancestorAttr === stored.ancestorAttr && live.ancestorValue === stored.ancestorValue) {
+      signal = live.ancestorTag === stored.ancestorTag ? 1 : ANCESTOR_PARTIAL_CREDIT;
+    }
+    add(WEIGHT_ANCESTOR, signal);
+  }
+  return weightSum === 0 ? 0 : scoreSum / weightSum;
+}
+function selectorPool(target, doc) {
+  if (target.selector === null) return null;
+  try {
+    return querySelectorAllDeep(doc, target.selector);
+  } catch {
+    return null;
+  }
+}
+function scanPool(target, doc) {
+  const storedTag = target.core.tag;
+  const pool = [];
+  for (const el of collectElementsDeep(doc)) {
+    if (el.tagName.toLowerCase() === storedTag || isInteractive(el))
+      pool.push(el);
+  }
+  return pool;
+}
+function evaluatePool(target, pool) {
+  if (pool.length === 0)
+    return { status: "not_found", reason: "no_candidates", matchCount: 0 };
+  const threshold = PRECISION_THRESHOLDS[target.precision];
+  let sawVisible = false;
+  let passing = [];
+  for (const el of pool) {
+    if (!isVisible(el)) continue;
+    sawVisible = true;
+    const score = scoreFingerprint(
+      target.core,
+      captureEventFingerprint(el),
+      target.dynamicText
+    );
+    if (score >= threshold) passing.push({ element: el, score });
+  }
+  passing = passing.filter((p, i) => {
+    const next = passing[i + 1];
+    if (next === void 0) return true;
+    return !(containsAcrossShadow(p.element, next.element) && p.score <= next.score);
+  });
+  if (passing.length === 0) {
+    return {
+      status: "not_found",
+      reason: sawVisible ? "below_threshold" : "not_visible",
+      matchCount: 0
+    };
+  }
+  const picked = target.ordinal >= 1 ? passing[target.ordinal - 1] : void 0;
+  if (picked === void 0) {
+    return {
+      status: "not_found",
+      reason: "ordinal_out_of_range",
+      matchCount: passing.length
+    };
+  }
+  return {
+    status: "matched",
+    element: picked.element,
+    score: picked.score,
+    matchCount: passing.length
+  };
+}
+function matchTarget(target, doc) {
+  try {
+    const fromSelector = selectorPool(target, doc);
+    if (fromSelector !== null && fromSelector.length > 0) {
+      const result = evaluatePool(target, fromSelector);
+      if (result.status === "matched" || result.reason === "ordinal_out_of_range")
+        return result;
+    }
+    return evaluatePool(target, scanPool(target, doc));
+  } catch {
+    return { status: "not_found", reason: "error", matchCount: 0 };
+  }
+}
+
+export { matchTarget };