@bigbinary/neeto-approvals-frontend 0.4.0-beta1 → 0.4.0-beta2

package/dist/index.js

@@ -1,24 +1,25 @@
-import * as React from 'react';
-import React__default, { useState, useEffect, useRef, createElement, useMemo } from 'react';
+import React, { useState, useEffect, useRef, createElement, useMemo } from 'react';
 import { useMutationWithInvalidation, useDebounce, withT, useQueryParams } from '@bigbinary/neeto-commons-frontend/react-utils';
 import Container from '@bigbinary/neeto-molecules/Container';
 import { Link, useLocation, useHistory, Switch, Route, Redirect, useParams } from 'react-router-dom';
 import i18next, { t as t$1 } from 'i18next';
 import { DEFAULT_PAGE_INDEX, DEFAULT_PAGE_SIZE, PLURAL, SINGULAR } from '@bigbinary/neeto-commons-frontend/constants';
 import Button from '@bigbinary/neetoui/Button';
-import { capitalize, isPresent, findBy, camelToSnakeCase, removeBy, noop as noop$1 } from '@bigbinary/neeto-cist';
+import { capitalize, isPresent, findBy, camelToSnakeCase, removeBy, noop } from '@bigbinary/neeto-cist';
 import TableWrapper from '@bigbinary/neeto-molecules/TableWrapper';
 import Table$1 from '@bigbinary/neetoui/Table';
 import NoData from '@bigbinary/neetoui/NoData';
 import { isEmpty, keys } from 'ramda';
 import { useTranslation, Trans } from 'react-i18next';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useQuery, keepPreviousData } from '@tanstack/react-query';
 import axios from 'axios';
 import Tag from '@bigbinary/neetoui/Tag';
 import DateFormat from '@bigbinary/neeto-molecules/DateFormat';
-import { isEditorEmpty, EditorContent, FormikEditor } from '@bigbinary/neeto-editor';
+import { isEditorEmpty } from '@bigbinary/neeto-editor/utils';
 import * as yup from 'yup';
-import { dateFormat, withEventTargetValue } from '@bigbinary/neeto-commons-frontend/utils';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { dateFormat, withEventTargetValue, captureAnalyticsEvent } from '@bigbinary/neeto-commons-frontend/utils';
+import EditorContent from '@bigbinary/neeto-editor/EditorContent';
 import Label from '@bigbinary/neetoui/Label';
 import Pane from '@bigbinary/neetoui/Pane';
 import Textarea from '@bigbinary/neetoui/Textarea';
@@ -35,6 +36,7 @@ import { useFormikContext } from 'formik';
 import ToggleFeatureCard from '@bigbinary/neeto-molecules/ToggleFeatureCard';
 import Input from '@bigbinary/neetoui/formik/Input';
 import Textarea$1 from '@bigbinary/neetoui/formik/Textarea';
+import FormikEditor from '@bigbinary/neeto-editor/FormikEditor';
 import MoreDropdown from '@bigbinary/neeto-molecules/MoreDropdown';
 import NeetoHeader from '@bigbinary/neeto-molecules/Header';
 import NeetoUITab from '@bigbinary/neetoui/Tab';
@@ -156,868 +158,6 @@ var handleEmptyPage = function handleEmptyPage(data, pageProperties, handlePageC
   }
 };
 
-// src/subscribable.ts
-var Subscribable = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.subscribe = this.subscribe.bind(this);
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    this.onSubscribe();
-    return () => {
-      this.listeners.delete(listener);
-      this.onUnsubscribe();
-    };
-  }
-  hasListeners() {
-    return this.listeners.size > 0;
-  }
-  onSubscribe() {
-  }
-  onUnsubscribe() {
-  }
-};
-
-// src/utils.ts
-var isServer = typeof window === "undefined" || "Deno" in globalThis;
-function noop() {
-  return void 0;
-}
-function isValidTimeout(value) {
-  return typeof value === "number" && value >= 0 && value !== Infinity;
-}
-function timeUntilStale(updatedAt, staleTime) {
-  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
-}
-function replaceEqualDeep(a, b) {
-  if (a === b) {
-    return a;
-  }
-  const array = isPlainArray(a) && isPlainArray(b);
-  if (array || isPlainObject(a) && isPlainObject(b)) {
-    const aItems = array ? a : Object.keys(a);
-    const aSize = aItems.length;
-    const bItems = array ? b : Object.keys(b);
-    const bSize = bItems.length;
-    const copy = array ? [] : {};
-    let equalItems = 0;
-    for (let i = 0; i < bSize; i++) {
-      const key = array ? i : bItems[i];
-      if ((!array && aItems.includes(key) || array) && a[key] === void 0 && b[key] === void 0) {
-        copy[key] = void 0;
-        equalItems++;
-      } else {
-        copy[key] = replaceEqualDeep(a[key], b[key]);
-        if (copy[key] === a[key] && a[key] !== void 0) {
-          equalItems++;
-        }
-      }
-    }
-    return aSize === bSize && equalItems === aSize ? a : copy;
-  }
-  return b;
-}
-function shallowEqualObjects(a, b) {
-  if (!b || Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const key in a) {
-    if (a[key] !== b[key]) {
-      return false;
-    }
-  }
-  return true;
-}
-function isPlainArray(value) {
-  return Array.isArray(value) && value.length === Object.keys(value).length;
-}
-function isPlainObject(o) {
-  if (!hasObjectPrototype(o)) {
-    return false;
-  }
-  const ctor = o.constructor;
-  if (ctor === void 0) {
-    return true;
-  }
-  const prot = ctor.prototype;
-  if (!hasObjectPrototype(prot)) {
-    return false;
-  }
-  if (!prot.hasOwnProperty("isPrototypeOf")) {
-    return false;
-  }
-  if (Object.getPrototypeOf(o) !== Object.prototype) {
-    return false;
-  }
-  return true;
-}
-function hasObjectPrototype(o) {
-  return Object.prototype.toString.call(o) === "[object Object]";
-}
-function replaceData(prevData, data, options) {
-  if (typeof options.structuralSharing === "function") {
-    return options.structuralSharing(prevData, data);
-  } else if (options.structuralSharing !== false) {
-    return replaceEqualDeep(prevData, data);
-  }
-  return data;
-}
-function keepPreviousData(previousData) {
-  return previousData;
-}
-
-// src/focusManager.ts
-var FocusManager = class extends Subscribable {
-  #focused;
-  #cleanup;
-  #setup;
-  constructor() {
-    super();
-    this.#setup = (onFocus) => {
-      if (!isServer && window.addEventListener) {
-        const listener = () => onFocus();
-        window.addEventListener("visibilitychange", listener, false);
-        return () => {
-          window.removeEventListener("visibilitychange", listener);
-        };
-      }
-      return;
-    };
-  }
-  onSubscribe() {
-    if (!this.#cleanup) {
-      this.setEventListener(this.#setup);
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.#cleanup?.();
-      this.#cleanup = void 0;
-    }
-  }
-  setEventListener(setup) {
-    this.#setup = setup;
-    this.#cleanup?.();
-    this.#cleanup = setup((focused) => {
-      if (typeof focused === "boolean") {
-        this.setFocused(focused);
-      } else {
-        this.onFocus();
-      }
-    });
-  }
-  setFocused(focused) {
-    const changed = this.#focused !== focused;
-    if (changed) {
-      this.#focused = focused;
-      this.onFocus();
-    }
-  }
-  onFocus() {
-    const isFocused = this.isFocused();
-    this.listeners.forEach((listener) => {
-      listener(isFocused);
-    });
-  }
-  isFocused() {
-    if (typeof this.#focused === "boolean") {
-      return this.#focused;
-    }
-    return globalThis.document?.visibilityState !== "hidden";
-  }
-};
-var focusManager = new FocusManager();
-
-// src/onlineManager.ts
-var OnlineManager = class extends Subscribable {
-  #online = true;
-  #cleanup;
-  #setup;
-  constructor() {
-    super();
-    this.#setup = (onOnline) => {
-      if (!isServer && window.addEventListener) {
-        const onlineListener = () => onOnline(true);
-        const offlineListener = () => onOnline(false);
-        window.addEventListener("online", onlineListener, false);
-        window.addEventListener("offline", offlineListener, false);
-        return () => {
-          window.removeEventListener("online", onlineListener);
-          window.removeEventListener("offline", offlineListener);
-        };
-      }
-      return;
-    };
-  }
-  onSubscribe() {
-    if (!this.#cleanup) {
-      this.setEventListener(this.#setup);
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.#cleanup?.();
-      this.#cleanup = void 0;
-    }
-  }
-  setEventListener(setup) {
-    this.#setup = setup;
-    this.#cleanup?.();
-    this.#cleanup = setup(this.setOnline.bind(this));
-  }
-  setOnline(online) {
-    const changed = this.#online !== online;
-    if (changed) {
-      this.#online = online;
-      this.listeners.forEach((listener) => {
-        listener(online);
-      });
-    }
-  }
-  isOnline() {
-    return this.#online;
-  }
-};
-var onlineManager = new OnlineManager();
-
-// src/retryer.ts
-function canFetch(networkMode) {
-  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
-}
-
-// src/notifyManager.ts
-function createNotifyManager() {
-  let queue = [];
-  let transactions = 0;
-  let notifyFn = (callback) => {
-    callback();
-  };
-  let batchNotifyFn = (callback) => {
-    callback();
-  };
-  let scheduleFn = (cb) => setTimeout(cb, 0);
-  const setScheduler = (fn) => {
-    scheduleFn = fn;
-  };
-  const batch = (callback) => {
-    let result;
-    transactions++;
-    try {
-      result = callback();
-    } finally {
-      transactions--;
-      if (!transactions) {
-        flush();
-      }
-    }
-    return result;
-  };
-  const schedule = (callback) => {
-    if (transactions) {
-      queue.push(callback);
-    } else {
-      scheduleFn(() => {
-        notifyFn(callback);
-      });
-    }
-  };
-  const batchCalls = (callback) => {
-    return (...args) => {
-      schedule(() => {
-        callback(...args);
-      });
-    };
-  };
-  const flush = () => {
-    const originalQueue = queue;
-    queue = [];
-    if (originalQueue.length) {
-      scheduleFn(() => {
-        batchNotifyFn(() => {
-          originalQueue.forEach((callback) => {
-            notifyFn(callback);
-          });
-        });
-      });
-    }
-  };
-  const setNotifyFunction = (fn) => {
-    notifyFn = fn;
-  };
-  const setBatchNotifyFunction = (fn) => {
-    batchNotifyFn = fn;
-  };
-  return {
-    batch,
-    batchCalls,
-    schedule,
-    setNotifyFunction,
-    setBatchNotifyFunction,
-    setScheduler
-  };
-}
-var notifyManager = createNotifyManager();
-
-// src/query.ts
-function fetchState(data, options) {
-  return {
-    fetchFailureCount: 0,
-    fetchFailureReason: null,
-    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
-    ...data === void 0 && {
-      error: null,
-      status: "pending"
-    }
-  };
-}
-
-// src/queryObserver.ts
-var QueryObserver = class extends Subscribable {
-  constructor(client, options) {
-    super();
-    this.options = options;
-    this.#client = client;
-    this.#selectError = null;
-    this.bindMethods();
-    this.setOptions(options);
-  }
-  #client;
-  #currentQuery = void 0;
-  #currentQueryInitialState = void 0;
-  #currentResult = void 0;
-  #currentResultState;
-  #currentResultOptions;
-  #selectError;
-  #selectFn;
-  #selectResult;
-  // This property keeps track of the last query with defined data.
-  // It will be used to pass the previous data and query to the placeholder function between renders.
-  #lastQueryWithDefinedData;
-  #staleTimeoutId;
-  #refetchIntervalId;
-  #currentRefetchInterval;
-  #trackedProps = /* @__PURE__ */ new Set();
-  bindMethods() {
-    this.refetch = this.refetch.bind(this);
-  }
-  onSubscribe() {
-    if (this.listeners.size === 1) {
-      this.#currentQuery.addObserver(this);
-      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
-        this.#executeFetch();
-      } else {
-        this.updateResult();
-      }
-      this.#updateTimers();
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) {
-      this.destroy();
-    }
-  }
-  shouldFetchOnReconnect() {
-    return shouldFetchOn(
-      this.#currentQuery,
-      this.options,
-      this.options.refetchOnReconnect
-    );
-  }
-  shouldFetchOnWindowFocus() {
-    return shouldFetchOn(
-      this.#currentQuery,
-      this.options,
-      this.options.refetchOnWindowFocus
-    );
-  }
-  destroy() {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.#clearStaleTimeout();
-    this.#clearRefetchInterval();
-    this.#currentQuery.removeObserver(this);
-  }
-  setOptions(options, notifyOptions) {
-    const prevOptions = this.options;
-    const prevQuery = this.#currentQuery;
-    this.options = this.#client.defaultQueryOptions(options);
-    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean") {
-      throw new Error("Expected enabled to be a boolean");
-    }
-    this.#updateQuery();
-    this.#currentQuery.setOptions(this.options);
-    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
-      this.#client.getQueryCache().notify({
-        type: "observerOptionsUpdated",
-        query: this.#currentQuery,
-        observer: this
-      });
-    }
-    const mounted = this.hasListeners();
-    if (mounted && shouldFetchOptionally(
-      this.#currentQuery,
-      prevQuery,
-      this.options,
-      prevOptions
-    )) {
-      this.#executeFetch();
-    }
-    this.updateResult(notifyOptions);
-    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
-      this.#updateStaleTimeout();
-    }
-    const nextRefetchInterval = this.#computeRefetchInterval();
-    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.#currentRefetchInterval)) {
-      this.#updateRefetchInterval(nextRefetchInterval);
-    }
-  }
-  getOptimisticResult(options) {
-    const query = this.#client.getQueryCache().build(this.#client, options);
-    const result = this.createResult(query, options);
-    if (shouldAssignObserverCurrentProperties(this, result)) {
-      this.#currentResult = result;
-      this.#currentResultOptions = this.options;
-      this.#currentResultState = this.#currentQuery.state;
-    }
-    return result;
-  }
-  getCurrentResult() {
-    return this.#currentResult;
-  }
-  trackResult(result, onPropTracked) {
-    const trackedResult = {};
-    Object.keys(result).forEach((key) => {
-      Object.defineProperty(trackedResult, key, {
-        configurable: false,
-        enumerable: true,
-        get: () => {
-          this.trackProp(key);
-          onPropTracked?.(key);
-          return result[key];
-        }
-      });
-    });
-    return trackedResult;
-  }
-  trackProp(key) {
-    this.#trackedProps.add(key);
-  }
-  getCurrentQuery() {
-    return this.#currentQuery;
-  }
-  refetch({ ...options } = {}) {
-    return this.fetch({
-      ...options
-    });
-  }
-  fetchOptimistic(options) {
-    const defaultedOptions = this.#client.defaultQueryOptions(options);
-    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
-    query.isFetchingOptimistic = true;
-    return query.fetch().then(() => this.createResult(query, defaultedOptions));
-  }
-  fetch(fetchOptions) {
-    return this.#executeFetch({
-      ...fetchOptions,
-      cancelRefetch: fetchOptions.cancelRefetch ?? true
-    }).then(() => {
-      this.updateResult();
-      return this.#currentResult;
-    });
-  }
-  #executeFetch(fetchOptions) {
-    this.#updateQuery();
-    let promise = this.#currentQuery.fetch(
-      this.options,
-      fetchOptions
-    );
-    if (!fetchOptions?.throwOnError) {
-      promise = promise.catch(noop);
-    }
-    return promise;
-  }
-  #updateStaleTimeout() {
-    this.#clearStaleTimeout();
-    if (isServer || this.#currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
-      return;
-    }
-    const time = timeUntilStale(
-      this.#currentResult.dataUpdatedAt,
-      this.options.staleTime
-    );
-    const timeout = time + 1;
-    this.#staleTimeoutId = setTimeout(() => {
-      if (!this.#currentResult.isStale) {
-        this.updateResult();
-      }
-    }, timeout);
-  }
-  #computeRefetchInterval() {
-    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
-  }
-  #updateRefetchInterval(nextInterval) {
-    this.#clearRefetchInterval();
-    this.#currentRefetchInterval = nextInterval;
-    if (isServer || this.options.enabled === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
-      return;
-    }
-    this.#refetchIntervalId = setInterval(() => {
-      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
-        this.#executeFetch();
-      }
-    }, this.#currentRefetchInterval);
-  }
-  #updateTimers() {
-    this.#updateStaleTimeout();
-    this.#updateRefetchInterval(this.#computeRefetchInterval());
-  }
-  #clearStaleTimeout() {
-    if (this.#staleTimeoutId) {
-      clearTimeout(this.#staleTimeoutId);
-      this.#staleTimeoutId = void 0;
-    }
-  }
-  #clearRefetchInterval() {
-    if (this.#refetchIntervalId) {
-      clearInterval(this.#refetchIntervalId);
-      this.#refetchIntervalId = void 0;
-    }
-  }
-  createResult(query, options) {
-    const prevQuery = this.#currentQuery;
-    const prevOptions = this.options;
-    const prevResult = this.#currentResult;
-    const prevResultState = this.#currentResultState;
-    const prevResultOptions = this.#currentResultOptions;
-    const queryChange = query !== prevQuery;
-    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
-    const { state } = query;
-    let newState = { ...state };
-    let isPlaceholderData = false;
-    let data;
-    if (options._optimisticResults) {
-      const mounted = this.hasListeners();
-      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
-      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-      if (fetchOnMount || fetchOptionally) {
-        newState = {
-          ...newState,
-          ...fetchState(state.data, query.options)
-        };
-      }
-      if (options._optimisticResults === "isRestoring") {
-        newState.fetchStatus = "idle";
-      }
-    }
-    let { error, errorUpdatedAt, status } = newState;
-    if (options.select && newState.data !== void 0) {
-      if (prevResult && newState.data === prevResultState?.data && options.select === this.#selectFn) {
-        data = this.#selectResult;
-      } else {
-        try {
-          this.#selectFn = options.select;
-          data = options.select(newState.data);
-          data = replaceData(prevResult?.data, data, options);
-          this.#selectResult = data;
-          this.#selectError = null;
-        } catch (selectError) {
-          this.#selectError = selectError;
-        }
-      }
-    } else {
-      data = newState.data;
-    }
-    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
-      let placeholderData;
-      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
-        placeholderData = prevResult.data;
-      } else {
-        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
-          this.#lastQueryWithDefinedData?.state.data,
-          this.#lastQueryWithDefinedData
-        ) : options.placeholderData;
-        if (options.select && placeholderData !== void 0) {
-          try {
-            placeholderData = options.select(placeholderData);
-            this.#selectError = null;
-          } catch (selectError) {
-            this.#selectError = selectError;
-          }
-        }
-      }
-      if (placeholderData !== void 0) {
-        status = "success";
-        data = replaceData(
-          prevResult?.data,
-          placeholderData,
-          options
-        );
-        isPlaceholderData = true;
-      }
-    }
-    if (this.#selectError) {
-      error = this.#selectError;
-      data = this.#selectResult;
-      errorUpdatedAt = Date.now();
-      status = "error";
-    }
-    const isFetching = newState.fetchStatus === "fetching";
-    const isPending = status === "pending";
-    const isError = status === "error";
-    const isLoading = isPending && isFetching;
-    const hasData = data !== void 0;
-    const result = {
-      status,
-      fetchStatus: newState.fetchStatus,
-      isPending,
-      isSuccess: status === "success",
-      isError,
-      isInitialLoading: isLoading,
-      isLoading,
-      data,
-      dataUpdatedAt: newState.dataUpdatedAt,
-      error,
-      errorUpdatedAt,
-      failureCount: newState.fetchFailureCount,
-      failureReason: newState.fetchFailureReason,
-      errorUpdateCount: newState.errorUpdateCount,
-      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
-      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
-      isFetching,
-      isRefetching: isFetching && !isPending,
-      isLoadingError: isError && !hasData,
-      isPaused: newState.fetchStatus === "paused",
-      isPlaceholderData,
-      isRefetchError: isError && hasData,
-      isStale: isStale(query, options),
-      refetch: this.refetch
-    };
-    return result;
-  }
-  updateResult(notifyOptions) {
-    const prevResult = this.#currentResult;
-    const nextResult = this.createResult(this.#currentQuery, this.options);
-    this.#currentResultState = this.#currentQuery.state;
-    this.#currentResultOptions = this.options;
-    if (this.#currentResultState.data !== void 0) {
-      this.#lastQueryWithDefinedData = this.#currentQuery;
-    }
-    if (shallowEqualObjects(nextResult, prevResult)) {
-      return;
-    }
-    this.#currentResult = nextResult;
-    const defaultNotifyOptions = {};
-    const shouldNotifyListeners = () => {
-      if (!prevResult) {
-        return true;
-      }
-      const { notifyOnChangeProps } = this.options;
-      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
-      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) {
-        return true;
-      }
-      const includedProps = new Set(
-        notifyOnChangePropsValue ?? this.#trackedProps
-      );
-      if (this.options.throwOnError) {
-        includedProps.add("error");
-      }
-      return Object.keys(this.#currentResult).some((key) => {
-        const typedKey = key;
-        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
-        return changed && includedProps.has(typedKey);
-      });
-    };
-    if (notifyOptions?.listeners !== false && shouldNotifyListeners()) {
-      defaultNotifyOptions.listeners = true;
-    }
-    this.#notify({ ...defaultNotifyOptions, ...notifyOptions });
-  }
-  #updateQuery() {
-    const query = this.#client.getQueryCache().build(this.#client, this.options);
-    if (query === this.#currentQuery) {
-      return;
-    }
-    const prevQuery = this.#currentQuery;
-    this.#currentQuery = query;
-    this.#currentQueryInitialState = query.state;
-    if (this.hasListeners()) {
-      prevQuery?.removeObserver(this);
-      query.addObserver(this);
-    }
-  }
-  onQueryUpdate() {
-    this.updateResult();
-    if (this.hasListeners()) {
-      this.#updateTimers();
-    }
-  }
-  #notify(notifyOptions) {
-    notifyManager.batch(() => {
-      if (notifyOptions.listeners) {
-        this.listeners.forEach((listener) => {
-          listener(this.#currentResult);
-        });
-      }
-      this.#client.getQueryCache().notify({
-        query: this.#currentQuery,
-        type: "observerResultsUpdated"
-      });
-    });
-  }
-};
-function shouldLoadOnMount(query, options) {
-  return options.enabled !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
-}
-function shouldFetchOnMount(query, options) {
-  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
-}
-function shouldFetchOn(query, options, field) {
-  if (options.enabled !== false) {
-    const value = typeof field === "function" ? field(query) : field;
-    return value === "always" || value !== false && isStale(query, options);
-  }
-  return false;
-}
-function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-  return (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
-}
-function isStale(query, options) {
-  return options.enabled !== false && query.isStaleByTime(options.staleTime);
-}
-function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
-  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
-    return true;
-  }
-  return false;
-}
-
-var QueryClientContext = React.createContext(
-  void 0
-);
-var useQueryClient = (queryClient) => {
-  const client = React.useContext(QueryClientContext);
-  if (queryClient) {
-    return queryClient;
-  }
-  if (!client) {
-    throw new Error("No QueryClient set, use QueryClientProvider to set one");
-  }
-  return client;
-};
-
-var IsRestoringContext = React.createContext(false);
-var useIsRestoring = () => React.useContext(IsRestoringContext);
-IsRestoringContext.Provider;
-
-function createValue() {
-  let isReset = false;
-  return {
-    clearReset: () => {
-      isReset = false;
-    },
-    reset: () => {
-      isReset = true;
-    },
-    isReset: () => {
-      return isReset;
-    }
-  };
-}
-var QueryErrorResetBoundaryContext = React.createContext(createValue());
-var useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);
-
-// src/utils.ts
-function shouldThrowError(throwError, params) {
-  if (typeof throwError === "function") {
-    return throwError(...params);
-  }
-  return !!throwError;
-}
-
-var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
-  if (options.suspense || options.throwOnError) {
-    if (!errorResetBoundary.isReset()) {
-      options.retryOnMount = false;
-    }
-  }
-};
-var useClearResetErrorBoundary = (errorResetBoundary) => {
-  React.useEffect(() => {
-    errorResetBoundary.clearReset();
-  }, [errorResetBoundary]);
-};
-var getHasError = ({
-  result,
-  errorResetBoundary,
-  throwOnError,
-  query
-}) => {
-  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && shouldThrowError(throwOnError, [result.error, query]);
-};
-
-// src/suspense.ts
-var ensureStaleTime = (defaultedOptions) => {
-  if (defaultedOptions.suspense) {
-    if (typeof defaultedOptions.staleTime !== "number") {
-      defaultedOptions.staleTime = 1e3;
-    }
-  }
-};
-var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
-var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
-  errorResetBoundary.clearReset();
-});
-
-function useBaseQuery(options, Observer, queryClient) {
-  const client = useQueryClient(queryClient);
-  const isRestoring = useIsRestoring();
-  const errorResetBoundary = useQueryErrorResetBoundary();
-  const defaultedOptions = client.defaultQueryOptions(options);
-  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
-  ensureStaleTime(defaultedOptions);
-  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
-  useClearResetErrorBoundary(errorResetBoundary);
-  const [observer] = React.useState(
-    () => new Observer(
-      client,
-      defaultedOptions
-    )
-  );
-  const result = observer.getOptimisticResult(defaultedOptions);
-  React.useSyncExternalStore(
-    React.useCallback(
-      (onStoreChange) => {
-        const unsubscribe = isRestoring ? () => void 0 : observer.subscribe(notifyManager.batchCalls(onStoreChange));
-        observer.updateResult();
-        return unsubscribe;
-      },
-      [observer, isRestoring]
-    ),
-    () => observer.getCurrentResult(),
-    () => observer.getCurrentResult()
-  );
-  React.useEffect(() => {
-    observer.setOptions(defaultedOptions, { listeners: false });
-  }, [defaultedOptions, observer]);
-  if (shouldSuspend(defaultedOptions, result)) {
-    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
-  }
-  if (getHasError({
-    result,
-    errorResetBoundary,
-    throwOnError: defaultedOptions.throwOnError,
-    query: client.getQueryCache().get(defaultedOptions.queryHash)
-  })) {
-    throw result.error;
-  }
-  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
-}
-
-function useQuery(options, queryClient) {
-  return useBaseQuery(options, QueryObserver, queryClient);
-}
-
 var BASE_URL = "neeto_approvals";
 var TEMPLATE_URL = "".concat(BASE_URL, "/templates");
 
@@ -1139,6 +279,9 @@ var REQUEST_FORM_VALIDATION_SCHEMA = yup.object().shape({
   }),
   approver: yup.object().required(t$1("neetoApprovals.validations.approver"))
 });
+var EVENTS = {
+  APPROVAL_TEMPLATE_CREATED: "approval_template_created"
+};
 
 var HISTORY_TABLE_COLUMNS = [{
   dataIndex: "approvalLabel",
@@ -1265,7 +408,7 @@ var getApprovalFilter = function getApprovalFilter() {
   };
 };
 
-var MemoizedEditorContent$1 = /*#__PURE__*/React__default.memo(EditorContent);
+var MemoizedEditorContent$1 = /*#__PURE__*/React.memo(EditorContent);
 var RequestDetailsPane = function RequestDetailsPane(_ref) {
   var _window$globalProps, _window$globalProps2;
   var isOpen = _ref.isOpen,
@@ -1658,10 +801,13 @@ var useFetchTemplate = function useFetchTemplate(_ref) {
     enabled: !!id
   });
 };
-var useCreateTemplate = function useCreateTemplate(options) {
-  return useMutationWithInvalidation(templatesApi.create, _objectSpread$8({
-    keysToInvalidate: [[QUERY_KEYS.TEMPLATES], [QUERY_KEYS.VIEWS]]
-  }, options));
+var useCreateTemplate = function useCreateTemplate() {
+  return useMutationWithInvalidation(templatesApi.create, {
+    keysToInvalidate: [[QUERY_KEYS.TEMPLATES], [QUERY_KEYS.VIEWS]],
+    onSuccess: function onSuccess() {
+      return captureAnalyticsEvent(EVENTS.APPROVAL_TEMPLATE_CREATED);
+    }
+  });
 };
 var useUpdateTemplate = function useUpdateTemplate(options) {
   return useMutationWithInvalidation(templatesApi.update, _objectSpread$8({
@@ -1763,7 +909,7 @@ var Form$2 = function Form(_ref) {
     _ref$initialData = _ref.initialData,
     initialData = _ref$initialData === void 0 ? {} : _ref$initialData,
     _ref$onSubmit = _ref.onSubmit,
-    onSubmit = _ref$onSubmit === void 0 ? noop$1 : _ref$onSubmit,
+    onSubmit = _ref$onSubmit === void 0 ? noop : _ref$onSubmit,
     _ref$isLoading = _ref.isLoading,
     isLoading = _ref$isLoading === void 0 ? false : _ref$isLoading,
     placeholders = _ref.placeholders;
@@ -1895,9 +1041,9 @@ var Field = function Field(_ref) {
     })]
   });
 };
-var Field$1 = /*#__PURE__*/React__default.memo(Field);
+var Field$1 = /*#__PURE__*/React.memo(Field);
 
-var MemoizedEditorContent = /*#__PURE__*/React__default.memo(EditorContent);
+var MemoizedEditorContent = /*#__PURE__*/React.memo(EditorContent);
 var TemplateDetails = function TemplateDetails(_ref) {
   var isOpen = _ref.isOpen,
     onClose = _ref.onClose,