@hortiview/modulebase 0.0.1-7.1-beta

package/dist/module-router.js

@@ -0,0 +1,129 @@
+import { useCallback as r } from "react";
+import { useBasePropsStore as t } from "./stores/BasePropsStore.js";
+import { A as R, B as F, F as E, H as N, I as l, a as A, b as _, L as v, c as d, M as m, d as U, N as g, e as h, f as C, O as p, P, R as H, g as y, h as L, i as k, S as x, j as D, k as w, l as I, m as M, D as O, n as b, E as B, o as T, p as f, q as V, r as q, s as z, t as G, u as K, v as W, V as j, w as J, x as Q, y as X, z as Y, C as Z, G as $, J as aa, K as ea, Q as sa, T as ta, U as ra, W as oa, X as ia, Y as ua, Z as na, _ as ca, $ as Sa, a0 as Ra, a1 as Fa, a2 as Ea, a3 as Na, a4 as la, a5 as Aa, a6 as _a, a7 as va, a8 as da, a9 as ma, aa as Ua, ab as ga, ac as ha, ad as Ca, ae as pa, af as Pa, ag as Ha, ah as ya, ai as La, aj as ka, ak as xa, al as Da, am as wa, an as Ia, ao as Ma, ap as Oa, aq as ba, ar as Ba, as as Ta, at as fa, au as Va, av as qa, aw as za, ax as Ga, ay as Ka, az as Wa, aA as ja, aB as Ja, aC as Qa, aD as Xa, aE as Ya, aF as Za, aG as $a, aH as ae, aI as ee, aJ as se, aK as te, aL as re, aM as oe, aN as ie, aO as ue, aP as ne, aQ as ce, aR as Se, aS as Re, aT as Fe } from "./chunk-IR6S3I6Y-BmDdD3SP.js";
+const n = () => {
+  const s = t((a) => a.navigateTo), e = t((a) => a.navigateInHortiview);
+  return r(
+    (a) => {
+      if (e) {
+        e(a);
+        return;
+      }
+      s?.(a);
+    },
+    [e, s]
+  );
+};
+export {
+  R as Await,
+  F as BrowserRouter,
+  E as Form,
+  N as HashRouter,
+  l as IDLE_BLOCKER,
+  A as IDLE_FETCHER,
+  _ as IDLE_NAVIGATION,
+  v as Link,
+  d as Links,
+  m as MemoryRouter,
+  U as Meta,
+  g as NavLink,
+  h as Navigate,
+  C as NavigationType,
+  p as Outlet,
+  P as PrefetchPageLinks,
+  H as Route,
+  y as Router,
+  L as RouterProvider,
+  k as Routes,
+  x as Scripts,
+  D as ScrollRestoration,
+  w as ServerRouter,
+  I as StaticRouter,
+  M as StaticRouterProvider,
+  O as UNSAFE_DataRouterContext,
+  b as UNSAFE_DataRouterStateContext,
+  B as UNSAFE_ErrorResponseImpl,
+  T as UNSAFE_FetchersContext,
+  f as UNSAFE_FrameworkContext,
+  V as UNSAFE_LocationContext,
+  q as UNSAFE_NavigationContext,
+  z as UNSAFE_RemixErrorBoundary,
+  G as UNSAFE_RouteContext,
+  K as UNSAFE_ServerMode,
+  W as UNSAFE_SingleFetchRedirectSymbol,
+  j as UNSAFE_ViewTransitionContext,
+  J as UNSAFE_createBrowserHistory,
+  Q as UNSAFE_createClientRoutes,
+  X as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
+  Y as UNSAFE_createRouter,
+  Z as UNSAFE_decodeViaTurboStream,
+  $ as UNSAFE_deserializeErrors,
+  aa as UNSAFE_getPatchRoutesOnNavigationFunction,
+  ea as UNSAFE_getSingleFetchDataStrategy,
+  sa as UNSAFE_invariant,
+  ta as UNSAFE_mapRouteProperties,
+  ra as UNSAFE_shouldHydrateRouteLoader,
+  oa as UNSAFE_useFogOFWarDiscovery,
+  ia as UNSAFE_useScrollRestoration,
+  ua as createBrowserRouter,
+  na as createCookie,
+  ca as createCookieSessionStorage,
+  Sa as createHashRouter,
+  Ra as createMemoryRouter,
+  Fa as createMemorySessionStorage,
+  Ea as createPath,
+  Na as createRequestHandler,
+  la as createRoutesFromChildren,
+  Aa as createRoutesFromElements,
+  _a as createRoutesStub,
+  va as createSearchParams,
+  da as createSession,
+  ma as createSessionStorage,
+  Ua as createStaticHandler,
+  ga as createStaticRouter,
+  ha as data,
+  Ca as generatePath,
+  pa as isCookie,
+  Pa as isRouteErrorResponse,
+  Ha as isSession,
+  ya as matchPath,
+  La as matchRoutes,
+  ka as parsePath,
+  xa as redirect,
+  Da as redirectDocument,
+  wa as renderMatches,
+  Ia as replace,
+  Ma as resolvePath,
+  Oa as unstable_HistoryRouter,
+  ba as unstable_setDevServerHooks,
+  Ba as unstable_usePrompt,
+  Ta as useActionData,
+  fa as useAsyncError,
+  Va as useAsyncValue,
+  qa as useBeforeUnload,
+  za as useBlocker,
+  Ga as useFetcher,
+  Ka as useFetchers,
+  Wa as useFormAction,
+  ja as useHref,
+  Ja as useInRouterContext,
+  Qa as useLinkClickHandler,
+  Xa as useLoaderData,
+  Ya as useLocation,
+  Za as useMatch,
+  $a as useMatches,
+  n as useNavigate,
+  ae as useNavigation,
+  ee as useNavigationType,
+  se as useOutlet,
+  te as useOutletContext,
+  re as useParams,
+  oe as useResolvedPath,
+  ie as useRevalidator,
+  ue as useRouteError,
+  ne as useRouteLoaderData,
+  ce as useRoutes,
+  Se as useSearchParams,
+  Re as useSubmit,
+  Fe as useViewTransitionState
+};

package/dist/mutation-DSKlaYzY.js

@@ -0,0 +1,192 @@
+import { R as o, c as a, n as r } from "./QueryClientProvider-Beog9TR7.js";
+var d = class extends o {
+  #e;
+  #t;
+  #i;
+  constructor(t) {
+    super(), this.mutationId = t.mutationId, this.#t = t.mutationCache, this.#e = [], this.state = t.state || u(), this.setOptions(t.options), this.scheduleGc();
+  }
+  setOptions(t) {
+    this.options = t, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(t) {
+    this.#e.includes(t) || (this.#e.push(t), this.clearGcTimeout(), this.#t.notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: t
+    }));
+  }
+  removeObserver(t) {
+    this.#e = this.#e.filter((i) => i !== t), this.scheduleGc(), this.#t.notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: t
+    });
+  }
+  optionalRemove() {
+    this.#e.length || (this.state.status === "pending" ? this.scheduleGc() : this.#t.remove(this));
+  }
+  continue() {
+    return this.#i?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(t) {
+    this.#i = a({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(t) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (e, n) => {
+        this.#s({ type: "failed", failureCount: e, error: n });
+      },
+      onPause: () => {
+        this.#s({ type: "pause" });
+      },
+      onContinue: () => {
+        this.#s({ type: "continue" });
+      },
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => this.#t.canRun(this)
+    });
+    const i = this.state.status === "pending", s = !this.#i.canStart();
+    try {
+      if (!i) {
+        this.#s({ type: "pending", variables: t, isPaused: s }), await this.#t.config.onMutate?.(
+          t,
+          this
+        );
+        const n = await this.options.onMutate?.(t);
+        n !== this.state.context && this.#s({
+          type: "pending",
+          context: n,
+          variables: t,
+          isPaused: s
+        });
+      }
+      const e = await this.#i.start();
+      return await this.#t.config.onSuccess?.(
+        e,
+        t,
+        this.state.context,
+        this
+      ), await this.options.onSuccess?.(e, t, this.state.context), await this.#t.config.onSettled?.(
+        e,
+        null,
+        this.state.variables,
+        this.state.context,
+        this
+      ), await this.options.onSettled?.(e, null, t, this.state.context), this.#s({ type: "success", data: e }), e;
+    } catch (e) {
+      try {
+        throw await this.#t.config.onError?.(
+          e,
+          t,
+          this.state.context,
+          this
+        ), await this.options.onError?.(
+          e,
+          t,
+          this.state.context
+        ), await this.#t.config.onSettled?.(
+          void 0,
+          e,
+          this.state.variables,
+          this.state.context,
+          this
+        ), await this.options.onSettled?.(
+          void 0,
+          e,
+          t,
+          this.state.context
+        ), e;
+      } finally {
+        this.#s({ type: "error", error: e });
+      }
+    } finally {
+      this.#t.runNext(this);
+    }
+  }
+  #s(t) {
+    const i = (s) => {
+      switch (t.type) {
+        case "failed":
+          return {
+            ...s,
+            failureCount: t.failureCount,
+            failureReason: t.error
+          };
+        case "pause":
+          return {
+            ...s,
+            isPaused: !0
+          };
+        case "continue":
+          return {
+            ...s,
+            isPaused: !1
+          };
+        case "pending":
+          return {
+            ...s,
+            context: t.context,
+            data: void 0,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: t.isPaused,
+            status: "pending",
+            variables: t.variables,
+            submittedAt: Date.now()
+          };
+        case "success":
+          return {
+            ...s,
+            data: t.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: "success",
+            isPaused: !1
+          };
+        case "error":
+          return {
+            ...s,
+            data: void 0,
+            error: t.error,
+            failureCount: s.failureCount + 1,
+            failureReason: t.error,
+            isPaused: !1,
+            status: "error"
+          };
+      }
+    };
+    this.state = i(this.state), r.batch(() => {
+      this.#e.forEach((s) => {
+        s.onMutationUpdate(t);
+      }), this.#t.notify({
+        mutation: this,
+        type: "updated",
+        action: t
+      });
+    });
+  }
+};
+function u() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+export {
+  d as M,
+  u as g
+};