@btst/stack 2.12.2 → 3.0.0-rc.2

package/dist/packages/stack/src/client/hooks/use-list-state.mjs

@@ -0,0 +1,147 @@
+"use client";
+import { useSyncExternalStore, useState, useCallback } from 'react';
+import { useStackOrNull } from '../../context/provider.mjs';
+import { parseListStateFromSearchParams, serializeListStateToSearchParams, resolveListStateHistoryMode } from '../../shared/list-state.mjs';
+export { listStateParamKey } from '../../shared/list-state.mjs';
+
+let urlVersion = 0;
+const urlListeners = /* @__PURE__ */ new Set();
+function notifyUrlChanged() {
+  urlVersion++;
+  for (const listener of urlListeners) listener();
+}
+function subscribeToUrl(listener) {
+  if (urlListeners.size === 0 && typeof window !== "undefined") {
+    window.addEventListener("popstate", notifyUrlChanged);
+  }
+  urlListeners.add(listener);
+  return () => {
+    urlListeners.delete(listener);
+    if (urlListeners.size === 0 && typeof window !== "undefined") {
+      window.removeEventListener("popstate", notifyUrlChanged);
+    }
+  };
+}
+function getUrlVersion() {
+  return urlVersion;
+}
+function getServerUrlVersion() {
+  return 0;
+}
+let pendingQueue = null;
+function searchParamsEqual(a, b) {
+  const sorted = (params) => {
+    const copy = new URLSearchParams(params.toString());
+    copy.sort();
+    return copy.toString();
+  };
+  return sorted(a) === sorted(b);
+}
+function enqueueListStateUpdate(update) {
+  if (pendingQueue) {
+    pendingQueue.push(update);
+    return;
+  }
+  pendingQueue = [update];
+  queueMicrotask(() => {
+    const queue = pendingQueue;
+    pendingQueue = null;
+    if (!queue || queue.length === 0) return;
+    const first = queue[0];
+    const currentParams = first.getSearchParams();
+    let params = currentParams;
+    let replace = true;
+    let changed = false;
+    for (const entry of queue) {
+      const prevState = parseListStateFromSearchParams(
+        entry.namespace,
+        entry.schema,
+        params
+      );
+      const nextState = { ...prevState, ...entry.patch };
+      if (Object.keys(entry.schema).every(
+        (key) => Object.is(prevState[key], nextState[key])
+      )) {
+        continue;
+      }
+      changed = true;
+      params = serializeListStateToSearchParams(
+        entry.namespace,
+        entry.schema,
+        nextState,
+        params
+      );
+      if (!resolveListStateHistoryMode(
+        entry.schema,
+        entry.patch,
+        entry.explicitReplace
+      )) {
+        replace = false;
+      }
+    }
+    if (!changed || searchParamsEqual(params, currentParams)) return;
+    first.setSearchParams(params, { replace });
+    notifyUrlChanged();
+  });
+}
+function useListState(namespace, schema) {
+  const stack = useStackOrNull();
+  const router = stack?.router;
+  const getSearchParams = router?.getSearchParams;
+  const setSearchParams = router?.setSearchParams;
+  const hasWriteBinding = !!getSearchParams && !!setSearchParams;
+  useSyncExternalStore(subscribeToUrl, getUrlVersion, getServerUrlVersion);
+  const urlState = parseListStateFromSearchParams(
+    namespace,
+    schema,
+    getSearchParams?.() ?? new URLSearchParams()
+  );
+  const [localPatch, setLocalPatch] = useState({});
+  const setState = useCallback(
+    (updates, options) => {
+      if (!setSearchParams || !getSearchParams) {
+        setLocalPatch((prevPatch) => {
+          const urlBase = parseListStateFromSearchParams(
+            namespace,
+            schema,
+            getSearchParams?.() ?? new URLSearchParams()
+          );
+          const prev = { ...urlBase, ...prevPatch };
+          const patch2 = typeof updates === "function" ? updates(prev) : updates;
+          if (!patch2 || Object.keys(patch2).length === 0) return prevPatch;
+          return { ...prevPatch, ...patch2 };
+        });
+        return;
+      }
+      let baseState = parseListStateFromSearchParams(
+        namespace,
+        schema,
+        getSearchParams()
+      );
+      if (pendingQueue) {
+        for (const entry of pendingQueue) {
+          if (entry.namespace === namespace) {
+            baseState = { ...baseState, ...entry.patch };
+          }
+        }
+      }
+      const patch = typeof updates === "function" ? updates(baseState) : updates;
+      if (!patch || Object.keys(patch).length === 0) return;
+      enqueueListStateUpdate({
+        namespace,
+        schema,
+        patch: { ...patch },
+        explicitReplace: options?.replace,
+        getSearchParams,
+        setSearchParams
+      });
+    },
+    [namespace, schema, setSearchParams, getSearchParams]
+  );
+  return [
+    hasWriteBinding ? urlState : { ...urlState, ...localPatch },
+    setState
+  ];
+}
+
+export { parseListStateFromSearchParams, serializeListStateToSearchParams, useListState };

package/dist/packages/stack/src/context/auth.cjs

@@ -0,0 +1,122 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+
+const AuthContext = React.createContext(null);
+function StackAuthBoundary({
+  provider,
+  children
+}) {
+  const [state, setState] = React.useState({ identity: null, isPending: true });
+  const refetch = React.useCallback(async () => {
+    try {
+      const identity = await provider.getIdentity();
+      setState({ identity: identity ?? null, isPending: false });
+    } catch (error) {
+      console.error("[btst/auth] getIdentity() failed:", error);
+      setState({ identity: null, isPending: false });
+    }
+  }, [provider]);
+  React.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    AuthContext.Provider,
+    {
+      value: {
+        provider,
+        identity: state.identity,
+        isPending: state.isPending,
+        refetch
+      },
+      children
+    }
+  );
+}
+function useAuthContext() {
+  return React.useContext(AuthContext);
+}
+function useIdentity() {
+  const auth = React.useContext(AuthContext);
+  if (!auth) {
+    return { identity: null, isPending: false, refetch: async () => {
+    } };
+  }
+  return {
+    identity: auth.identity,
+    isPending: auth.isPending,
+    refetch: auth.refetch
+  };
+}
+function useCan(params) {
+  const auth = React.useContext(AuthContext);
+  const canFn = auth?.provider.can;
+  const identity = auth?.identity ?? null;
+  const identityPending = auth?.isPending ?? false;
+  const { resource, action, params: extraParams } = params;
+  const extraParamsKey = extraParams ? JSON.stringify(extraParams) : "";
+  const extraParamsRef = React.useRef(extraParams);
+  extraParamsRef.current = extraParams;
+  const checkKey = `${resource}\0${action}\0${extraParamsKey}`;
+  const [resolved, setResolved] = React.useState(null);
+  React.useEffect(() => {
+    if (!canFn || identityPending) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const currentParams = extraParamsRef.current;
+        const allowed = await canFn({
+          resource,
+          action,
+          ...currentParams ? { params: currentParams } : {},
+          identity
+        });
+        if (!cancelled) {
+          setResolved({
+            can: allowed,
+            forIdentity: identity,
+            forKey: checkKey
+          });
+        }
+      } catch (error) {
+        console.error("[btst/auth] can() failed:", error);
+        if (!cancelled) {
+          setResolved({ can: false, forIdentity: identity, forKey: checkKey });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [canFn, identity, identityPending, resource, action, checkKey]);
+  if (!auth || !canFn) {
+    return { can: true, isPending: false };
+  }
+  if (identityPending) {
+    return { can: false, isPending: true };
+  }
+  if (!resolved || resolved.forIdentity !== identity || resolved.forKey !== checkKey) {
+    return { can: false, isPending: true };
+  }
+  return { can: resolved.can, isPending: false };
+}
+function CanAccess({
+  resource,
+  action,
+  params,
+  fallback = null,
+  loading = null,
+  children
+}) {
+  const { can, isPending } = useCan({ resource, action, params });
+  if (isPending) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loading });
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: can ? children : fallback });
+}
+
+exports.CanAccess = CanAccess;
+exports.StackAuthBoundary = StackAuthBoundary;
+exports.useAuthContext = useAuthContext;
+exports.useCan = useCan;
+exports.useIdentity = useIdentity;

package/dist/packages/stack/src/context/auth.mjs

@@ -0,0 +1,116 @@
+"use client";
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { useContext, createContext, useRef, useState, useEffect, useCallback } from 'react';
+
+const AuthContext = createContext(null);
+function StackAuthBoundary({
+  provider,
+  children
+}) {
+  const [state, setState] = useState({ identity: null, isPending: true });
+  const refetch = useCallback(async () => {
+    try {
+      const identity = await provider.getIdentity();
+      setState({ identity: identity ?? null, isPending: false });
+    } catch (error) {
+      console.error("[btst/auth] getIdentity() failed:", error);
+      setState({ identity: null, isPending: false });
+    }
+  }, [provider]);
+  useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return /* @__PURE__ */ jsx(
+    AuthContext.Provider,
+    {
+      value: {
+        provider,
+        identity: state.identity,
+        isPending: state.isPending,
+        refetch
+      },
+      children
+    }
+  );
+}
+function useAuthContext() {
+  return useContext(AuthContext);
+}
+function useIdentity() {
+  const auth = useContext(AuthContext);
+  if (!auth) {
+    return { identity: null, isPending: false, refetch: async () => {
+    } };
+  }
+  return {
+    identity: auth.identity,
+    isPending: auth.isPending,
+    refetch: auth.refetch
+  };
+}
+function useCan(params) {
+  const auth = useContext(AuthContext);
+  const canFn = auth?.provider.can;
+  const identity = auth?.identity ?? null;
+  const identityPending = auth?.isPending ?? false;
+  const { resource, action, params: extraParams } = params;
+  const extraParamsKey = extraParams ? JSON.stringify(extraParams) : "";
+  const extraParamsRef = useRef(extraParams);
+  extraParamsRef.current = extraParams;
+  const checkKey = `${resource}\0${action}\0${extraParamsKey}`;
+  const [resolved, setResolved] = useState(null);
+  useEffect(() => {
+    if (!canFn || identityPending) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const currentParams = extraParamsRef.current;
+        const allowed = await canFn({
+          resource,
+          action,
+          ...currentParams ? { params: currentParams } : {},
+          identity
+        });
+        if (!cancelled) {
+          setResolved({
+            can: allowed,
+            forIdentity: identity,
+            forKey: checkKey
+          });
+        }
+      } catch (error) {
+        console.error("[btst/auth] can() failed:", error);
+        if (!cancelled) {
+          setResolved({ can: false, forIdentity: identity, forKey: checkKey });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [canFn, identity, identityPending, resource, action, checkKey]);
+  if (!auth || !canFn) {
+    return { can: true, isPending: false };
+  }
+  if (identityPending) {
+    return { can: false, isPending: true };
+  }
+  if (!resolved || resolved.forIdentity !== identity || resolved.forKey !== checkKey) {
+    return { can: false, isPending: true };
+  }
+  return { can: resolved.can, isPending: false };
+}
+function CanAccess({
+  resource,
+  action,
+  params,
+  fallback = null,
+  loading = null,
+  children
+}) {
+  const { can, isPending } = useCan({ resource, action, params });
+  if (isPending) return /* @__PURE__ */ jsx(Fragment, { children: loading });
+  return /* @__PURE__ */ jsx(Fragment, { children: can ? children : fallback });
+}
+
+export { CanAccess, StackAuthBoundary, useAuthContext, useCan, useIdentity };

package/dist/packages/stack/src/context/i18n.cjs

@@ -0,0 +1,28 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const interpolate = require('../shared/interpolate.cjs');
+
+const I18nContext = React.createContext(null);
+function StackI18nBoundary({
+  i18n,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(I18nContext.Provider, { value: i18n ?? null, children });
+}
+function useTranslate() {
+  const i18n = React.useContext(I18nContext);
+  const fallback = React.useCallback(
+    (key, defaultValue, params) => interpolate.interpolate(defaultValue, params),
+    []
+  );
+  return React.useMemo(() => {
+    if (!i18n) return fallback;
+    return (key, defaultValue, params) => i18n.translate(key, defaultValue, params);
+  }, [i18n, fallback]);
+}
+
+exports.StackI18nBoundary = StackI18nBoundary;
+exports.useTranslate = useTranslate;

package/dist/packages/stack/src/context/i18n.mjs

@@ -0,0 +1,25 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useContext, createContext, useCallback, useMemo } from 'react';
+import { interpolate } from '../shared/interpolate.mjs';
+
+const I18nContext = createContext(null);
+function StackI18nBoundary({
+  i18n,
+  children
+}) {
+  return /* @__PURE__ */ jsx(I18nContext.Provider, { value: i18n ?? null, children });
+}
+function useTranslate() {
+  const i18n = useContext(I18nContext);
+  const fallback = useCallback(
+    (key, defaultValue, params) => interpolate(defaultValue, params),
+    []
+  );
+  return useMemo(() => {
+    if (!i18n) return fallback;
+    return (key, defaultValue, params) => i18n.translate(key, defaultValue, params);
+  }, [i18n, fallback]);
+}
+
+export { StackI18nBoundary, useTranslate };

package/dist/packages/stack/src/context/notify.cjs

@@ -0,0 +1,45 @@
+"use client";
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const sonner = require('sonner');
+
+const NotifyContext = React.createContext(null);
+const defaultNotifyProvider = {
+  success: (message, options) => {
+    sonner.toast.success(message, options);
+  },
+  error: (message, options) => {
+    sonner.toast.error(message, options);
+  },
+  info: (message, options) => {
+    sonner.toast.info(message, options);
+  },
+  warning: (message, options) => {
+    sonner.toast.warning(message, options);
+  }
+};
+function mergeNotifyProvider(custom) {
+  return {
+    success: custom?.success ?? defaultNotifyProvider.success,
+    error: custom?.error ?? defaultNotifyProvider.error,
+    info: custom?.info ?? defaultNotifyProvider.info,
+    warning: custom?.warning ?? defaultNotifyProvider.warning
+  };
+}
+function StackNotifyBoundary({
+  notify,
+  children
+}) {
+  const value = React.useMemo(() => mergeNotifyProvider(notify), [notify]);
+  return /* @__PURE__ */ jsxRuntime.jsx(NotifyContext.Provider, { value, children });
+}
+function useNotify() {
+  const notify = React.useContext(NotifyContext);
+  return notify ?? defaultNotifyProvider;
+}
+
+exports.StackNotifyBoundary = StackNotifyBoundary;
+exports.defaultNotifyProvider = defaultNotifyProvider;
+exports.useNotify = useNotify;

package/dist/packages/stack/src/context/notify.mjs

@@ -0,0 +1,41 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { useContext, createContext, useMemo } from 'react';
+import { toast } from 'sonner';
+
+const NotifyContext = createContext(null);
+const defaultNotifyProvider = {
+  success: (message, options) => {
+    toast.success(message, options);
+  },
+  error: (message, options) => {
+    toast.error(message, options);
+  },
+  info: (message, options) => {
+    toast.info(message, options);
+  },
+  warning: (message, options) => {
+    toast.warning(message, options);
+  }
+};
+function mergeNotifyProvider(custom) {
+  return {
+    success: custom?.success ?? defaultNotifyProvider.success,
+    error: custom?.error ?? defaultNotifyProvider.error,
+    info: custom?.info ?? defaultNotifyProvider.info,
+    warning: custom?.warning ?? defaultNotifyProvider.warning
+  };
+}
+function StackNotifyBoundary({
+  notify,
+  children
+}) {
+  const value = useMemo(() => mergeNotifyProvider(notify), [notify]);
+  return /* @__PURE__ */ jsx(NotifyContext.Provider, { value, children });
+}
+function useNotify() {
+  const notify = useContext(NotifyContext);
+  return notify ?? defaultNotifyProvider;
+}
+
+export { StackNotifyBoundary, defaultNotifyProvider, useNotify };

package/dist/packages/stack/src/context/provider.cjs

@@ -3,18 +3,66 @@
 
 const jsxRuntime = require('react/jsx-runtime');
 const React = require('react');
+const auth = require('./auth.cjs');
+const i18n = require('./i18n.cjs');
+const notify = require('./notify.cjs');
 
 const StackContext = React.createContext(null);
+function stripUndefined(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (obj[key] !== void 0) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function resolveStaticRouter(router) {
+  if (!router) return void 0;
+  const { useRouter: _useRouter, ...staticFields } = router;
+  return stripUndefined(staticFields);
+}
+function RouterBridge({
+  useRouter,
+  staticRouter,
+  value,
+  children
+}) {
+  const hookRouter = useRouter();
+  const router = {
+    ...staticRouter,
+    ...stripUndefined(hookRouter)
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(StackContext.Provider, { value: { ...value, router }, children });
+}
 function StackProvider({
   children,
   overrides,
-  basePath
+  basePath,
+  router,
+  api,
+  auth: auth$1,
+  notify: notify$1,
+  i18n: i18n$1
 }) {
+  const staticRouter = resolveStaticRouter(router);
   const value = {
-    overrides,
-    basePath
+    overrides: overrides ?? {},
+    basePath,
+    api,
+    auth: auth$1
   };
-  return /* @__PURE__ */ jsxRuntime.jsx(StackContext.Provider, { value, children });
+  const content = auth$1 ? /* @__PURE__ */ jsxRuntime.jsx(auth.StackAuthBoundary, { provider: auth$1, children }) : children;
+  const stackTree = router?.useRouter ? /* @__PURE__ */ jsxRuntime.jsx(
+    RouterBridge,
+    {
+      useRouter: router.useRouter,
+      staticRouter,
+      value,
+      children: content
+    }
+  ) : /* @__PURE__ */ jsxRuntime.jsx(StackContext.Provider, { value: { ...value, router: staticRouter }, children: content });
+  return /* @__PURE__ */ jsxRuntime.jsx(notify.StackNotifyBoundary, { notify: notify$1, children: /* @__PURE__ */ jsxRuntime.jsx(i18n.StackI18nBoundary, { i18n: i18n$1, children: stackTree }) });
 }
 function useStack() {
   const context = React.useContext(
@@ -27,10 +75,13 @@ function useStack() {
   }
   return context;
 }
+function useStackOrNull() {
+  return React.useContext(StackContext);
+}
 function usePluginOverrides(pluginName, defaultValues) {
-  const context = useStack();
-  const pluginOverrides = context.overrides[pluginName];
-  const overrides = defaultValues ? { ...defaultValues, ...pluginOverrides } : pluginOverrides;
+  const { overrides: allOverrides } = useStack();
+  const pluginOverrides = allOverrides[pluginName];
+  const overrides = defaultValues ? { ...defaultValues, ...pluginOverrides } : pluginOverrides ?? {};
   return overrides;
 }
 function useBasePath() {
@@ -47,3 +98,4 @@ exports.StackProvider = StackProvider;
 exports.useBasePath = useBasePath;
 exports.usePluginOverrides = usePluginOverrides;
 exports.useStack = useStack;
+exports.useStackOrNull = useStackOrNull;