@hortiview/modulebase 0.0.1 → 0.0.17-beta

package/dist/module-router.js

@@ -0,0 +1,137 @@
+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 _, a as l, b as A, L as d, c as U, M as v, d as h, N as m, e as g, f as C, O as p, P, R as y, g as H, h as x, i as k, S as L, j as w, k as D, l as b, m as I, D as B, n as M, E as O, o as T, p as f, q as V, r as W, s as q, t as z, u as G, v as K, 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 _a, a5 as la, a6 as Aa, a7 as da, a8 as Ua, a9 as va, aa as ha, ab as ma, ac as ga, ad as Ca, ae as pa, af as Pa, ag as ya, ah as Ha, ai as xa, aj as ka, ak as La, al as wa, am as Da, an as ba, ao as Ia, ap as Ba, aq as Ma, ar as Oa, as as Ta, at as fa, au as Va, av as Wa, aw as qa, ax as za, ay as Ga, az as Ka, 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, aU as Ee, aV as Ne, aW as _e, aX as le, aY as Ae, aZ as de, a_ as Ue, a$ as ve } from "./chunk-QMGIS6GS-C4bgXQXY.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,
+  _ as IDLE_BLOCKER,
+  l as IDLE_FETCHER,
+  A as IDLE_NAVIGATION,
+  d as Link,
+  U as Links,
+  v as MemoryRouter,
+  h as Meta,
+  m as NavLink,
+  g as Navigate,
+  C as NavigationType,
+  p as Outlet,
+  P as PrefetchPageLinks,
+  y as Route,
+  H as Router,
+  x as RouterProvider,
+  k as Routes,
+  L as Scripts,
+  w as ScrollRestoration,
+  D as ServerRouter,
+  b as StaticRouter,
+  I as StaticRouterProvider,
+  B as UNSAFE_DataRouterContext,
+  M as UNSAFE_DataRouterStateContext,
+  O as UNSAFE_ErrorResponseImpl,
+  T as UNSAFE_FetchersContext,
+  f as UNSAFE_FrameworkContext,
+  V as UNSAFE_LocationContext,
+  W as UNSAFE_NavigationContext,
+  q as UNSAFE_RemixErrorBoundary,
+  z as UNSAFE_RouteContext,
+  G as UNSAFE_ServerMode,
+  K 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_getHydrationData,
+  ea as UNSAFE_getPatchRoutesOnNavigationFunction,
+  sa as UNSAFE_getTurboStreamSingleFetchDataStrategy,
+  ta as UNSAFE_hydrationRouteProperties,
+  ra as UNSAFE_invariant,
+  oa as UNSAFE_mapRouteProperties,
+  ia as UNSAFE_shouldHydrateRouteLoader,
+  ua as UNSAFE_useFogOFWarDiscovery,
+  na as UNSAFE_useScrollRestoration,
+  ca as UNSAFE_withComponentProps,
+  Sa as UNSAFE_withErrorBoundaryProps,
+  Ra as UNSAFE_withHydrateFallbackProps,
+  Fa as createBrowserRouter,
+  Ea as createCookie,
+  Na as createCookieSessionStorage,
+  _a as createHashRouter,
+  la as createMemoryRouter,
+  Aa as createMemorySessionStorage,
+  da as createPath,
+  Ua as createRequestHandler,
+  va as createRoutesFromChildren,
+  ha as createRoutesFromElements,
+  ma as createRoutesStub,
+  ga as createSearchParams,
+  Ca as createSession,
+  pa as createSessionStorage,
+  Pa as createStaticHandler,
+  ya as createStaticRouter,
+  Ha as data,
+  xa as generatePath,
+  ka as href,
+  La as isCookie,
+  wa as isRouteErrorResponse,
+  Da as isSession,
+  ba as matchPath,
+  Ia as matchRoutes,
+  Ba as parsePath,
+  Ma as redirect,
+  Oa as redirectDocument,
+  Ta as renderMatches,
+  fa as replace,
+  Va as resolvePath,
+  Wa as unstable_HistoryRouter,
+  qa as unstable_RouterContextProvider,
+  za as unstable_createContext,
+  Ga as unstable_setDevServerHooks,
+  Ka as unstable_usePrompt,
+  ja as useActionData,
+  Ja as useAsyncError,
+  Qa as useAsyncValue,
+  Xa as useBeforeUnload,
+  Ya as useBlocker,
+  Za as useFetcher,
+  $a as useFetchers,
+  ae as useFormAction,
+  ee as useHref,
+  se as useInRouterContext,
+  te as useLinkClickHandler,
+  re as useLoaderData,
+  oe as useLocation,
+  ie as useMatch,
+  ue as useMatches,
+  n as useNavigate,
+  ne as useNavigation,
+  ce as useNavigationType,
+  Se as useOutlet,
+  Re as useOutletContext,
+  Fe as useParams,
+  Ee as useResolvedPath,
+  Ne as useRevalidator,
+  _e as useRouteError,
+  le as useRouteLoaderData,
+  Ae as useRoutes,
+  de as useSearchParams,
+  Ue as useSubmit,
+  ve 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
+};