@simplr-ai/vue 1.0.0

package/dist/index.cjs

@@ -0,0 +1,617 @@
+'use strict';
+
+var js = require('@simplr-ai/js');
+var vue = require('vue');
+
+// src/plugin.ts
+
+// src/keys.ts
+var SimplrInjectionKey = /* @__PURE__ */ Symbol("simplr");
+function installContext(app, ctx) {
+  app.provide(SimplrInjectionKey, ctx);
+  app.config.globalProperties.$simplr = ctx;
+}
+var stateMap = /* @__PURE__ */ new WeakMap();
+var vSimplrProtect = {
+  mounted(el, binding) {
+    attach(el, binding);
+  },
+  updated(el, binding) {
+    detach(el);
+    attach(el, binding);
+  },
+  beforeUnmount(el) {
+    detach(el);
+  }
+};
+function attach(el, binding) {
+  const value = binding.value;
+  const field = typeof value === "string" ? value : value?.field ?? "field";
+  const factory = typeof value === "object" && value?.trackInput ? value.trackInput : null;
+  el.setAttribute("data-simplr-field", field);
+  if (!factory) {
+    const state2 = {
+      field,
+      onKeyDown: () => {
+      },
+      onKeyUp: () => {
+      },
+      onPaste: () => {
+        if (js.simplrRUM.isInitialized()) {
+          js.simplrRUM.trackAction(`Paste into ${field}`, "custom", {
+            target: { tag: "input" }
+          });
+        }
+      }
+    };
+    el.addEventListener("paste", state2.onPaste);
+    stateMap.set(el, state2);
+    return;
+  }
+  const handlers = factory(field);
+  const state = {
+    field,
+    onKeyDown: handlers.onKeyDown,
+    onKeyUp: handlers.onKeyUp,
+    onPaste: handlers.onPaste
+  };
+  el.addEventListener("keydown", state.onKeyDown);
+  el.addEventListener("keyup", state.onKeyUp);
+  el.addEventListener("paste", state.onPaste);
+  stateMap.set(el, state);
+}
+function detach(el) {
+  const state = stateMap.get(el);
+  if (!state) return;
+  el.removeEventListener("keydown", state.onKeyDown);
+  el.removeEventListener("keyup", state.onKeyUp);
+  el.removeEventListener("paste", state.onPaste);
+  stateMap.delete(el);
+}
+
+// src/plugin.ts
+function resolveBlock(block, fallback) {
+  if (block === false || block === void 0) return void 0;
+  if (block === true) return fallback;
+  return { ...fallback, ...block };
+}
+function createSimplr(config = {}) {
+  const apiKey = config.apiKey;
+  const fraud = new js.SimplrFraud({ apiKey, ...config.fraud });
+  const flagsConfig = resolveBlock(config.flags, {
+    apiKey: apiKey ?? "",
+    baseUrl: config.baseUrl
+  });
+  let flags;
+  if (flagsConfig) {
+    flags = new js.SimplrFlags();
+    void flags.initialize(flagsConfig);
+  }
+  const profilesConfig = resolveBlock(config.profiles, {
+    apiKey: apiKey ?? "",
+    baseUrl: config.baseUrl
+  });
+  let profiles;
+  if (profilesConfig) {
+    profiles = new js.SimplrProfiles(profilesConfig);
+    profiles.setDeviceSignalCollector(() => fraud.collectDeviceSignals());
+  }
+  let rum = void 0;
+  if (config.rum) {
+    if (!js.simplrRUM.isInitialized()) {
+      js.simplrRUM.initialize(config.rum);
+    }
+    rum = js.simplrRUM;
+  }
+  const aiConfig = resolveBlock(config.ai, {
+    apiKey: apiKey ?? ""
+  });
+  let ai;
+  if (aiConfig && aiConfig.apiKey) {
+    ai = new js.SimplrAI(aiConfig);
+  }
+  const context = { fraud, flags, profiles, rum, ai };
+  const plugin = {
+    context,
+    install(app) {
+      installContext(app, context);
+      app.directive("simplr-protect", vSimplrProtect);
+    }
+  };
+  return plugin;
+}
+function useSimplrContext() {
+  const ctx = vue.inject(SimplrInjectionKey, null);
+  if (!ctx) {
+    throw new Error(
+      "[@simplr-ai/vue] No Simplr context found. Did you call app.use(createSimplr(...))?"
+    );
+  }
+  return ctx;
+}
+function useSimplr() {
+  const { fraud } = useSimplrContext();
+  return {
+    simplr: fraud,
+    isReady: vue.computed(() => fraud.isReady),
+    collect: () => fraud.collect(),
+    collectDeviceSignals: () => fraud.collectDeviceSignals(),
+    collectBehaviorSignals: () => fraud.collectBehaviorSignals(),
+    reset: () => fraud.reset(),
+    trackInput: (fieldName) => fraud.trackInput(fieldName),
+    startTracking: () => fraud.startTracking(),
+    stopTracking: () => fraud.stopTracking()
+  };
+}
+function useDeviceSignals(options = {}) {
+  const { fraud } = useSimplrContext();
+  const signals = vue.ref(null);
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  const refresh = async () => {
+    loading.value = true;
+    error.value = null;
+    try {
+      signals.value = await fraud.collectDeviceSignals();
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error("Failed to collect device signals");
+    } finally {
+      loading.value = false;
+    }
+  };
+  if (options.immediate !== false) {
+    vue.onMounted(refresh);
+  }
+  return { signals, loading, error, refresh };
+}
+function getFlags() {
+  const { flags } = useSimplrContext();
+  if (!flags) {
+    throw new Error(
+      "[@simplr-ai/vue] Feature flags are not configured. Pass `flags: true` (or a config) to createSimplr()."
+    );
+  }
+  return flags;
+}
+function useFlagsTick(flags) {
+  const tick = vue.ref(0);
+  const ready = vue.ref(flags.isReady());
+  let last = JSON.stringify(flags.getAll());
+  let timer = null;
+  const check = () => {
+    const wasReady = ready.value;
+    ready.value = flags.isReady();
+    const snapshot = JSON.stringify(flags.getAll());
+    if (snapshot !== last || ready.value !== wasReady) {
+      last = snapshot;
+      tick.value++;
+    }
+  };
+  vue.onMounted(() => {
+    check();
+    timer = setInterval(check, 500);
+  });
+  vue.onUnmounted(() => {
+    if (timer) clearInterval(timer);
+  });
+  return { tick, ready };
+}
+function useFeatureFlag(key, ctx) {
+  const flags = getFlags();
+  const { tick, ready } = useFlagsTick(flags);
+  const enabled = vue.computed(() => {
+    void tick.value;
+    return flags.isEnabled(vue.toValue(key), vue.toValue(ctx));
+  });
+  return { enabled, isReady: ready };
+}
+function useFeatureFlags(ctx) {
+  const client = getFlags();
+  const { tick, ready } = useFlagsTick(client);
+  const definitions = vue.computed(() => {
+    void tick.value;
+    return client.getAll();
+  });
+  const flags = vue.computed(() => {
+    void tick.value;
+    const evalCtx = vue.toValue(ctx);
+    const out = {};
+    for (const key of Object.keys(client.getAll())) {
+      out[key] = client.isEnabled(key, evalCtx);
+    }
+    return out;
+  });
+  return {
+    flags,
+    definitions,
+    isEnabled: (key, c) => client.isEnabled(key, c ?? vue.toValue(ctx)),
+    isReady: ready,
+    refresh: () => client.refresh(),
+    setUser: (userId) => client.setUser(userId)
+  };
+}
+function useProfiles() {
+  const { profiles } = useSimplrContext();
+  if (!profiles) {
+    throw new Error(
+      "[@simplr-ai/vue] Profiles are not configured. Pass `profiles: true` (or a config) to createSimplr()."
+    );
+  }
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  async function run(fn) {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await fn();
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+      throw error.value;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    profiles,
+    loading,
+    error,
+    identify: (externalId, options) => run(() => profiles.identify(externalId, options)),
+    submitOrder: (order) => run(() => profiles.submitOrder(order)),
+    getProfileRisk: (externalId) => run(() => profiles.getProfileRisk(externalId)),
+    reportOutcome: (externalId, outcome) => run(() => profiles.reportOutcome(externalId, outcome))
+  };
+}
+function useRum() {
+  const ctx = vue.inject(SimplrInjectionKey, null);
+  return ctx?.rum ?? js.simplrRUM;
+}
+function useTrackView(name) {
+  const rum = useRum();
+  vue.onMounted(() => {
+    if (rum.isInitialized()) rum.trackView(vue.toValue(name));
+  });
+}
+function useTrackAction() {
+  const rum = useRum();
+  return (name, type, attributes) => {
+    if (rum.isInitialized()) rum.trackAction(name, type, { attributes });
+  };
+}
+function useTrackError() {
+  const rum = useRum();
+  return (error, context) => {
+    if (rum.isInitialized()) rum.trackError(error, context);
+  };
+}
+function useRumLogger() {
+  const rum = useRum();
+  const make = (level) => (message, context) => {
+    if (rum.isInitialized()) rum.log(level, message, context);
+  };
+  return {
+    debug: make("debug"),
+    info: make("info"),
+    warn: make("warn"),
+    error: make("error")
+  };
+}
+function useRumUser() {
+  const rum = useRum();
+  return {
+    setUser: (userId, attributes) => {
+      if (rum.isInitialized()) rum.setUser(userId, attributes);
+    },
+    clearUser: () => {
+      if (rum.isInitialized()) rum.clearUser();
+    }
+  };
+}
+function useRumAttributes() {
+  const rum = useRum();
+  return {
+    addAttribute: (key, value) => rum.addAttribute(key, value),
+    removeAttribute: (key) => rum.removeAttribute(key)
+  };
+}
+function useTrackAsync(operationName) {
+  const rum = useRum();
+  return async (asyncFn) => {
+    const start = Date.now();
+    try {
+      const result = await asyncFn();
+      rum.trackAction(`${operationName} completed`, "custom", {
+        attributes: { duration: Date.now() - start, success: true }
+      });
+      return result;
+    } catch (error) {
+      rum.trackError(
+        error instanceof Error ? error : new Error(String(error)),
+        { operationName, duration: Date.now() - start }
+      );
+      throw error;
+    }
+  };
+}
+function flushRumOnUnmount() {
+  const rum = useRum();
+  vue.onUnmounted(() => {
+    void rum.flush();
+  });
+}
+function resolveClient(config) {
+  const ctx = vue.inject(SimplrInjectionKey, null);
+  if (ctx?.ai) return ctx.ai;
+  if (config) return new js.SimplrAI(config);
+  throw new Error(
+    "[@simplr-ai/vue] AI delegation is not configured. Pass `ai: true` to createSimplr() or supply a config to useAIDelegation()."
+  );
+}
+function useAIDelegation(config) {
+  const ai = resolveClient(config);
+  const loading = vue.ref(false);
+  const error = vue.ref(null);
+  async function run(fn) {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await fn();
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+      throw error.value;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    ai,
+    loading,
+    error,
+    connect: (options) => run(() => ai.connect(options)),
+    createDelegation: (options) => run(() => ai.createDelegation(options)),
+    validate: (token, options) => run(() => ai.validate(token, options)),
+    revoke: (delegationId, reason) => run(() => ai.revoke(delegationId, reason)),
+    list: (userId) => run(() => ai.list(userId)),
+    get: (delegationId) => run(() => ai.get(delegationId)),
+    stats: () => run(() => ai.stats()),
+    revokeAllForUser: (userId, reason) => run(() => ai.revokeAllForUser(userId, reason))
+  };
+}
+function useDelegations(config, userId) {
+  const ai = resolveClient(config);
+  const delegations = vue.ref([]);
+  const loading = vue.ref(true);
+  const error = vue.ref(null);
+  const refresh = async () => {
+    loading.value = true;
+    error.value = null;
+    try {
+      delegations.value = await ai.list(userId);
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+    } finally {
+      loading.value = false;
+    }
+  };
+  const revoke = async (delegationId, reason) => {
+    await ai.revoke(delegationId, reason);
+    await refresh();
+  };
+  vue.onMounted(refresh);
+  return { delegations, loading, error, refresh, revoke };
+}
+var _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "SimplrProtectedForm",
+  emits: ["submit", "error"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const emit = __emit;
+    const { collect } = useSimplr();
+    const submitting = vue.ref(false);
+    async function handleSubmit(event) {
+      event.preventDefault();
+      submitting.value = true;
+      try {
+        const signals = await collect();
+        emit("submit", signals, event);
+      } catch (e) {
+        emit("error", e instanceof Error ? e : new Error(String(e)));
+      } finally {
+        submitting.value = false;
+      }
+    }
+    __expose({ submitting });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(
+        "form",
+        { onSubmit: handleSubmit },
+        [vue.renderSlot(_ctx.$slots, "default", { submitting: submitting.value })],
+        32
+        /* NEED_HYDRATION */
+      );
+    };
+  }
+});
+var SimplrProtectedForm_default = _sfc_main;
+var _hoisted_1 = ["value", "data-simplr-field"];
+var _sfc_main2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "SimplrProtectedInput",
+  props: {
+    field: {},
+    modelValue: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { trackInput } = useSimplr();
+    const tracking = vue.computed(() => trackInput(props.field));
+    vue.watchEffect(() => {
+      void tracking.value;
+    });
+    function onInput(event) {
+      emit("update:modelValue", event.target.value);
+    }
+    function onKeyDown(e) {
+      tracking.value.onKeyDown(e);
+    }
+    function onKeyUp(e) {
+      tracking.value.onKeyUp(e);
+    }
+    function onPaste() {
+      tracking.value.onPaste();
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("input", {
+        value: __props.modelValue,
+        "data-simplr-field": __props.field,
+        onInput,
+        onKeydown: onKeyDown,
+        onKeyup: onKeyUp,
+        onPaste
+      }, null, 40, _hoisted_1);
+    };
+  }
+});
+var SimplrProtectedInput_default = _sfc_main2;
+var _sfc_main3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "RumView",
+  props: { name: {} },
+  setup(__props) {
+    const props = __props;
+    useTrackView(vue.toRef(props, "name"));
+    return (_ctx, _cache) => {
+      return vue.renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var RumView_default = _sfc_main3;
+var _sfc_main4 = /* @__PURE__ */ vue.defineComponent({
+  __name: "RumErrorBoundary",
+  emits: ["error"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const rum = useRum();
+    const error = vue.ref(null);
+    vue.onErrorCaptured((err, _instance, info) => {
+      const normalized = err instanceof Error ? err : new Error(String(err));
+      error.value = normalized;
+      if (rum.isInitialized()) {
+        rum.trackError(normalized, {
+          vueErrorInfo: info,
+          isVueError: true
+        });
+      }
+      emit("error", normalized, info);
+      return false;
+    });
+    return (_ctx, _cache) => {
+      return error.value ? vue.renderSlot(_ctx.$slots, "fallback", {
+        key: 0,
+        error: error.value
+      }, () => [_cache[0] || (_cache[0] = vue.createElementVNode(
+        "div",
+        { style: {
+          "padding": "20px",
+          "text-align": "center"
+        } },
+        [vue.createElementVNode("h2", null, "Something went wrong"), vue.createElementVNode("p", null, "We've been notified and are working to fix the issue.")],
+        -1
+        /* CACHED */
+      ))]) : vue.renderSlot(_ctx.$slots, "default", { key: 1 });
+    };
+  }
+});
+var RumErrorBoundary_default = _sfc_main4;
+function installRumErrorHandler(app, rum = js.simplrRUM) {
+  const previous = app.config.errorHandler;
+  app.config.errorHandler = (err, instance, info) => {
+    const normalized = err instanceof Error ? err : new Error(String(err));
+    if (rum.isInitialized()) {
+      rum.trackError(normalized, { vueErrorInfo: info, isVueError: true });
+    }
+    previous?.(err, instance, info);
+  };
+}
+
+Object.defineProperty(exports, "SimplrAI", {
+  enumerable: true,
+  get: function () { return js.SimplrAI; }
+});
+Object.defineProperty(exports, "SimplrFlags", {
+  enumerable: true,
+  get: function () { return js.SimplrFlags; }
+});
+Object.defineProperty(exports, "SimplrFraud", {
+  enumerable: true,
+  get: function () { return js.SimplrFraud; }
+});
+Object.defineProperty(exports, "SimplrProfiles", {
+  enumerable: true,
+  get: function () { return js.SimplrProfiles; }
+});
+Object.defineProperty(exports, "SimplrRUM", {
+  enumerable: true,
+  get: function () { return js.SimplrRUM; }
+});
+Object.defineProperty(exports, "clearDeviceId", {
+  enumerable: true,
+  get: function () { return js.clearDeviceId; }
+});
+Object.defineProperty(exports, "createFingerprintHash", {
+  enumerable: true,
+  get: function () { return js.createFingerprintHash; }
+});
+Object.defineProperty(exports, "createSimplrAI", {
+  enumerable: true,
+  get: function () { return js.createSimplrAI; }
+});
+Object.defineProperty(exports, "createSimplrProfiles", {
+  enumerable: true,
+  get: function () { return js.createSimplrProfiles; }
+});
+Object.defineProperty(exports, "getDeviceId", {
+  enumerable: true,
+  get: function () { return js.getDeviceId; }
+});
+Object.defineProperty(exports, "murmurHash3", {
+  enumerable: true,
+  get: function () { return js.murmurHash3; }
+});
+Object.defineProperty(exports, "sha256", {
+  enumerable: true,
+  get: function () { return js.sha256; }
+});
+Object.defineProperty(exports, "simplrFlags", {
+  enumerable: true,
+  get: function () { return js.simplrFlags; }
+});
+Object.defineProperty(exports, "simplrRUM", {
+  enumerable: true,
+  get: function () { return js.simplrRUM; }
+});
+exports.RumErrorBoundary = RumErrorBoundary_default;
+exports.RumView = RumView_default;
+exports.SimplrInjectionKey = SimplrInjectionKey;
+exports.SimplrProtectedForm = SimplrProtectedForm_default;
+exports.SimplrProtectedInput = SimplrProtectedInput_default;
+exports.createSimplr = createSimplr;
+exports.flushRumOnUnmount = flushRumOnUnmount;
+exports.installRumErrorHandler = installRumErrorHandler;
+exports.useAIDelegation = useAIDelegation;
+exports.useDelegations = useDelegations;
+exports.useDeviceSignals = useDeviceSignals;
+exports.useFeatureFlag = useFeatureFlag;
+exports.useFeatureFlags = useFeatureFlags;
+exports.useProfiles = useProfiles;
+exports.useRum = useRum;
+exports.useRumAttributes = useRumAttributes;
+exports.useRumLogger = useRumLogger;
+exports.useRumUser = useRumUser;
+exports.useSimplr = useSimplr;
+exports.useSimplrContext = useSimplrContext;
+exports.useTrackAction = useTrackAction;
+exports.useTrackAsync = useTrackAsync;
+exports.useTrackError = useTrackError;
+exports.useTrackView = useTrackView;
+exports.vSimplrProtect = vSimplrProtect;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map