sekisho 0.2.1 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 <h1 align="center">⛩️ sekisho</h1>
 <p align="center"><sup>(関所, <em>historical checkpoint for travel and security</em> in Japanese)</sup></p>
-<p align="center">Authentication and Access Control for any React app ([online demo](https://sekisho-demo.pages.dev/login))</p>
+<p align="center">Authentication and Access Control for any React app <a href="https://sekisho-demo.pages.dev" target="_blank">online demo</a></p>
 
 ----
 
@@ -61,38 +61,38 @@ export default function RootLayout({ children }: { children: React.ReactNode })
 }
 ```
 
-By default, `SekishoProvider` already includes `SekishoErrorBoundary` that will catch any `NotAuthenticatedError` thrown by `needLogin()` in the subtree. But if you have special error handling needs in certain parts of your app, you can also always import `SekishoErrorBoundary` directly to wrap those parts:
+By default, `SekishoProvider` already includes `NotAuthenticatedBoundary` that will catch any `NotAuthenticatedError` thrown by `needLogin()` in the subtree. But if you have special error handling needs in certain parts of your app, you can also always import `NotAuthenticatedBoundary` directly to wrap those parts:
 
 ```tsx
-import { SekishoErrorBoundary } from 'sekisho';
+import { NotAuthenticatedBoundary } from 'sekisho';
 
 function SomePartOfApp() {
   return (
-    <SekishoErrorBoundary>
+    <NotAuthenticatedBoundary>
       {/* ... */}
-    </SekishoErrorBoundary>
+    </NotAuthenticatedBoundary>
   );
 }
 ```
 
-And if you are using Next.js App Router and `error.tsx` file, due to Next.js layout, page, and error boundary heirarchy, you will also need to wrap the `error.tsx` with `SekishoErrorWrapper`:
+And if you are using Next.js App Router and `error.tsx` file, due to Next.js layout, page, and error boundary heirarchy, you will also need to wrap the `error.tsx` with `NotAuthenticatedErrorWrapper`:
 
 ```tsx
 // app/error.tsx
 'use client';
 
-import { SekishoErrorWrapper } from 'sekisho';
+import { NotAuthenticatedErrorWrapper } from 'sekisho';
 
 export default function ErrorPage({ error, reset }) {
   return (
-    <SekishoErrorWrapper error={error}>
+    <NotAuthenticatedErrorWrapper error={error}>
       {/* Your existing error UI goes in here */}
-    </SekishoErrorWrapper>
+    </NotAuthenticatedErrorWrapper>
   );
 }
 ```
 
-> `SekishoErrorWrapper` is actually used by `SekishoErrorBoundary` internally, containing all the core logic.
+> `NotAuthenticatedErrorWrapper` is actually used by `NotAuthenticatedBoundary` internally, containing all the core logic.
 
 ### Triggering a login redirect
 
@@ -133,10 +133,10 @@ export const requireAuthMiddleware: Middleware = (useSWRNext) => (key, fetcher,
 
 ### Restricting access
 
-Wrap any part of the UI with `SekishoAccessContainer` and call `accessRestricted()` inside it when the user lacks the required role or permission. Unlike `needLogin()`, which triggers a global redirect via `onNeedLogin`, `accessRestricted()` is local — `SekishoAccessContainer` simply renders `fallback` in place of its children:
+Wrap any part of the UI with `AccessRestrictedContainer` and call `accessRestricted()` inside it when the user lacks the required role or permission. Unlike `needLogin()`, which triggers a global redirect via `onNeedLogin`, `accessRestricted()` is local — `AccessRestrictedContainer` simply renders `fallback` in place of its children:
 
 ```tsx
-import { accessRestricted, SekishoAccessContainer } from 'sekisho';
+import { accessRestricted, AccessRestrictedContainer } from 'sekisho';
 
 function AdminPanel() {
   const { role } = useCurrentUser();
@@ -150,16 +150,16 @@ function AdminPanel() {
 
 function Page() {
   return (
-    <SekishoAccessContainer
+    <AccessRestrictedContainer
       fallback={<p>You don't have permission to view this section.</p>}
     >
       <AdminPanel />
-    </SekishoAccessContainer>
+    </AccessRestrictedContainer>
   );
 }
 ```
 
-This kinda like `<Suspense />` but for access control instead. And like `<Suspense />`, you can have multiple `SekishoAccessContainer`s nested independently — each one only catches the `accessRestricted()` calls within its own subtree.
+This kinda like `<Suspense />` but for access control instead. And like `<Suspense />`, you can have multiple `AccessRestrictedContainer`s nested independently — each one only catches the `accessRestricted()` calls within its own subtree.
 
 ## Explanation
 
@@ -167,12 +167,12 @@ Sekisho is built on top of React's error boundaries. Both `needLogin()` and `acc
 
 | Function | Error thrown | Caught by | Behaviour |
 |---|---|---|---|
-| `needLogin()` | `NotAuthenticatedError` | `SekishoErrorBoundary` / `SekishoErrorWrapper` | Calls `onNeedLogin` from `SekishoProvider` (global redirect) |
-| `accessRestricted()` | `AccessRestrictedError` | `SekishoAccessContainer` | Renders the `fallback` prop in place of children (local swap) |
+| `needLogin()` | `NotAuthenticatedError` | `NotAuthenticatedBoundary` / `NotAuthenticatedErrorWrapper` | Calls `onNeedLogin` from `SekishoProvider` (global redirect) |
+| `accessRestricted()` | `AccessRestrictedError` | `AccessRestrictedContainer` | Renders the `fallback` prop in place of children (local swap) |
 
-Each boundary re-throws errors it does not own, so `SekishoAccessContainer` never swallows an auth error, and `SekishoErrorBoundary` never swallows an access error. Your own error boundaries are unaffected by either.
+Each boundary re-throws errors it does not own, so `AccessRestrictedContainer` never swallows an auth error, and `NotAuthenticatedBoundary` never swallows an access error. Your own error boundaries are unaffected by either.
 
-With `SekishoErrorWrapper` / `SekishoErrorBoundary` you can create protected and unprotected routes in any React app:
+With `NotAuthenticatedErrorWrapper` / `NotAuthenticatedBoundary` you can create protected and unprotected routes in any React app:
 
 **Next.js App Router**
 
@@ -180,7 +180,7 @@ With `SekishoErrorWrapper` / `SekishoErrorBoundary` you can create protected and
 app/
 ├── (protected)/            ← all protected routes goes under here
 │   ├── layout.tsx          ← wrap children with <SekishoProvider> here
-│   ├── error.tsx           ← wrap with <SekishoErrorWrapper> here
+│   ├── error.tsx           ← wrap with <NotAuthenticatedErrorWrapper> here
 │   └── page.tsx            ← homepage, where you call needLogin() when authentication is needed
 ├── (unprotected)/          ← all unprotected routes goes under here
 │   └── login/
@@ -206,9 +206,9 @@ const router = createBrowserRouter([
       {
         component() {
           return (
-            <SekishoErrorBoundary>
+            <NotAuthenticatedBoundary>
               <Outlet />
-            </SekishoErrorBoundary>
+            </NotAuthenticatedBoundary>
           );
         },
         children: [
@@ -221,6 +221,53 @@ const router = createBrowserRouter([
 ]);
 ```
 
+## Build your own guard
+
+Sekisho also provides a low-level abstraction `createSekisho` from `sekisho/factory` for building your own custom gate with the same underlying mechanism. Let's say you want to build a guard for new user onboarding flow, where users need to complete their profile before accessing certain parts of the app:
+
+```tsx
+import { createSekisho } from 'sekisho/factory';
+
+const [requireOnboarding, OnboardingGate] = createSekisho('OnboardingRequired');
+
+function Dashboard() {
+  const user = useUser();
+
+  if (!user.profileComplete) {
+    requireOnboarding('Profile incomplete');
+  }
+
+  // actual dashboard content
+  return <div>Welcome back, {user.name}</div>;
+}
+
+function OnboardingGuard({ error }) {
+  redirect('/onboarding');
+}
+
+// Wrap your app with the boundary component
+function Page() {
+  return (
+    <OnboardingGate
+      fallback={<OnboardingGuard />}
+      // or you can pass a component that receives the error prop
+      fallbackComponent={OnboardingGuard}
+    >
+      <Dashboard />
+    </OnboardingGate>
+  );
+}
+```
+
+The `createSekisho()` factory returns a 4-tuple: `[throwFn, BoundaryComponent, isError, ErrorClass]`. You can name each element whatever makes sense for your use case:
+
+- **`throwFn`** — Call this during render to trigger the guard when a condition is unmet
+- **`BoundaryComponent`** — Error boundary that catches errors thrown by `throwFn`. Accepts `fallback` (static UI) or `fallbackComponent` (component that receives `{ error }`)
+- **`isError`** — Type guard to check if an error is from this guard (useful in middleware or error handlers)
+- **`ErrorClass`** — The error constructor, if you need `instanceof` checks
+
+Each call to `createSekisho()` is isolated — guards never accidentally catch each other's errors, even if nested.
+
 ## License
 
 [MIT](LICENSE)

package/dist/factory.cjs

@@ -0,0 +1 @@
+"use client";Object.defineProperty(exports,"__esModule",{value:!0});var r=require("react/jsx-runtime"),e=require("foxact/create-stackless-error"),t=require("react");exports.createSekisho=function(s){let o=new WeakSet;class n extends Error{constructor(r){super(r),this.digest="BAILOUT_TO_CLIENT_SIDE_RENDERING",this.name=s??"SekishoGuardError",o.add(this)}}function a(r){return!!r&&"object"==typeof r&&o.has(r)}class c extends t.Component{constructor(r){super(r),this.state={caughtError:null}}static getDerivedStateFromError(r){if(a(r))return{caughtError:r};throw r}render(){let{caughtError:e}=this.state;if(null!==e){let{fallback:t,fallbackComponent:s}=this.props;return s?r.jsx(s,{error:e}):t}return this.props.children}}return[function(r){throw e.createStacklessError(()=>new n(r))},c,a,n]};

package/dist/factory.d.ts

@@ -0,0 +1,65 @@
+/** Base interface for every guard error created by `createSekisho`. */
+interface SekishoGuardError extends Error {
+    readonly digest: 'BAILOUT_TO_CLIENT_SIDE_RENDERING';
+}
+/**
+ * Props accepted by the boundary component returned from `createSekisho`.
+ *
+ * Exactly one of `fallback` or `fallbackComponent` must be provided:
+ *
+ * - `fallback` — a static `ReactNode` rendered in place of children when the
+ *   guard fires (access-control pattern).
+ * - `fallbackComponent` — a React component that receives `{ error }` as props.
+ *   Use this when you need the caught error object, e.g. to trigger a
+ *   navigation side-effect (auth pattern).
+ */
+type SekishoGuardBoundaryProps = React.PropsWithChildren & ({
+    fallback: React.ReactNode;
+    fallbackComponent?: never;
+} | {
+    fallback?: never;
+    fallbackComponent: React.ComponentType<{
+        error: SekishoGuardError;
+    }>;
+});
+interface SekishoGuardBoundaryState {
+    caughtError: SekishoGuardError | null;
+}
+/**
+ * Creates a paired guard throw function, error boundary component, type guard,
+ * and error class — all isolated from every other guard in the tree.
+ *
+ * Call the returned throw function anywhere in the React render phase to signal
+ * that a condition is unmet. The nearest boundary component in the tree will
+ * catch it and render its `fallback` prop instead of `children`. Every other
+ * error boundary — including ones from other `createSekisho()` calls —
+ * re-throws the error unchanged.
+ *
+ * Returns a 4-tuple so each element can be named freely on destructure:
+ * `[throwFn, BoundaryComponent, isError, ErrorClass]`
+ *
+ * @example
+ * // Access-control pattern — static fallback element:
+ * const [requireOnboarding, OnboardingGate] = createSekisho();
+ *
+ * <OnboardingGate fallback={<OnboardingWizard />}>
+ *   <Profile />
+ * </OnboardingGate>
+ *
+ * @example
+ * // Callback pattern — component receives the error object:
+ * const [requireAuth, AuthGate] = createSekisho();
+ *
+ * <AuthGate fallbackComponent={AuthErrorHandler}>
+ *   <Dashboard />
+ * </AuthGate>
+ */
+declare function createSekisho(errorName?: string): [
+    throwError: (message: string) => never,
+    BoundaryComponent: React.ComponentClass<SekishoGuardBoundaryProps, SekishoGuardBoundaryState>,
+    isError: (error: unknown) => error is SekishoGuardError,
+    ErrorClass: new (message: string) => SekishoGuardError
+];
+
+export { createSekisho };
+export type { SekishoGuardBoundaryProps, SekishoGuardBoundaryState, SekishoGuardError };

package/dist/factory.mjs

@@ -0,0 +1 @@
+"use client";import{jsx as r}from"react/jsx-runtime";import{createStacklessError as t}from"foxact/create-stackless-error";import{Component as e}from"react";function o(o){let s=new WeakSet;class n extends Error{constructor(r){super(r),this.digest="BAILOUT_TO_CLIENT_SIDE_RENDERING",this.name=o??"SekishoGuardError",s.add(this)}}function i(r){return!!r&&"object"==typeof r&&s.has(r)}return[function(r){throw t(()=>new n(r))},class extends e{constructor(r){super(r),this.state={caughtError:null}}static getDerivedStateFromError(r){if(i(r))return{caughtError:r};throw r}render(){let{caughtError:t}=this.state;if(null!==t){let{fallback:e,fallbackComponent:o}=this.props;return o?r(o,{error:t}):e}return this.props.children}},i,n]}export{o as createSekisho};

package/dist/index.cjs

@@ -1 +1 @@
-"use client";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("foxact/create-stackless-error"),r=require("foxact/use-isomorphic-layout-effect"),t=require("foxact/nullthrow"),s=require("react"),o=require("foxact/use-stable-handler-only-when-you-know-what-you-are-doing-or-you-will-be-fired"),i=require("react/jsx-runtime");class n extends Error{constructor(...e){super(...e),this.name="NotAuthenticatedError",this.notAuthenticated=!0,this.$sekishoError=!0,this.digest="BAILOUT_TO_CLIENT_SIDE_RENDERING"}}function c(e){return!!e&&"object"==typeof e&&"notAuthenticated"in e&&!0===e.notAuthenticated&&"$sekishoError"in e&&!0===e.$sekishoError}let u=s.createContext(null);function a({error:e,children:i}){let{onNeedLogin:n}=t.nullthrow(s.useContext(u),"useSekishoOptions must be used within a SekishoOptionsProvider"),h=c(e),d=o.useStableHandler(n);return(r.useLayoutEffect(()=>{h&&d()},[h,d]),h)?null:i}class h extends s.Component{constructor(e){super(e),this.state={needLoginErrorObject:null}}static getDerivedStateFromError(e){if(c(e))return{needLoginErrorObject:e};throw e}render(){return this.state.needLoginErrorObject?i.jsx(a,{error:this.state.needLoginErrorObject,children:this.props.children}):this.props.children}}class d extends Error{constructor(...e){super(...e),this.name="AccessRestrictedError",this.accessRestricted=!0,this.$sekishoError=!0,this.digest="BAILOUT_TO_CLIENT_SIDE_RENDERING"}}function l(e){return!!e&&"object"==typeof e&&"accessRestricted"in e&&!0===e.accessRestricted&&"$sekishoError"in e&&!0===e.$sekishoError}class p extends s.Component{constructor(e){super(e),this.state={restricted:!1}}static getDerivedStateFromError(e){if(l(e))return{restricted:!0};throw e}render(){return this.state.restricted?this.props.fallback:this.props.children}}exports.AccessRestrictedError=d,exports.NotAuthenticatedError=n,exports.SekishoAccessContainer=p,exports.SekishoErrorBoundary=h,exports.SekishoErrorWrapper=a,exports.SekishoProvider=function({children:e,...r}){return i.jsx(u.Provider,{value:r,children:i.jsx(h,{children:e})})},exports.accessRestricted=function(r){throw e.createStacklessError(()=>new d(r))},exports.isAccessRestrictedError=l,exports.isNeedLoginError=c,exports.needLogin=function(r){throw e.createStacklessError(()=>new n(r))};
+"use client";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react/jsx-runtime"),r=require("foxact/use-isomorphic-layout-effect"),t=require("foxact/use-stable-handler-only-when-you-know-what-you-are-doing-or-you-will-be-fired"),o=require("./factory.cjs"),s=require("foxact/nullthrow"),i=require("react");let n=i.createContext(null),[c,u,a,l]=o.createSekisho("NotAuthenticatedError");function d({error:e,children:o}){let{onNeedLogin:c}=s.nullthrow(i.useContext(n),"useSekishoOptions must be used within a SekishoOptionsProvider"),u=a(e),l=t.useStableHandler(c);return(r.useLayoutEffect(()=>{u&&l()},[u,l]),u)?null:o}function p({children:r}){return e.jsx(u,{fallbackComponent:d,children:r})}let[h,x,f,k]=o.createSekisho("AccessRestrictedError");Object.defineProperty(exports,"createSekisho",{enumerable:!0,get:function(){return o.createSekisho}}),exports.AccessRestrictedContainer=x,exports.AccessRestrictedError=k,exports.NotAuthenticatedBoundary=p,exports.NotAuthenticatedError=l,exports.NotAuthenticatedErrorWrapper=d,exports.SekishoAccessContainer=x,exports.SekishoErrorBoundary=p,exports.SekishoErrorWrapper=d,exports.SekishoProvider=function({children:r,...t}){return e.jsx(n.Provider,{value:t,children:e.jsx(p,{children:r})})},exports.accessRestricted=h,exports.isAccessRestrictedError=f,exports.isNeedLoginError=a,exports.needLogin=c;

package/dist/index.d.ts

@@ -1,64 +1,39 @@
 import * as react from 'react';
-import { Component } from 'react';
+import * as __factory from './factory.js';
+import { SekishoGuardBoundaryProps } from './factory.js';
+export { SekishoGuardBoundaryProps, SekishoGuardBoundaryState, SekishoGuardError, createSekisho } from './factory.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-declare class NotAuthenticatedError extends Error {
-    readonly name = "NotAuthenticatedError";
-    readonly notAuthenticated = true;
-    readonly $sekishoError = true;
-    /**
-     * Normally, when React encounters an error during rendering in the server,
-     * it will find the nearest Suspense boundary and render its fallback (on
-     * the client it would find the nearest error boundary instead).
-     *
-     * For various purposes, Next.js also uses this mechanism to bail out of
-     * server-side rendering to do client-side rendering only. Thus Next.js
-     * create this magic digest 'BAILOUT_TO_CLIENT_SIDE_RENDERING' that does
-     * nothing but allow every error report (console, reportError, etc.) to
-     * skip this error
-     *
-     * Next.js doesn't handle this error in any special way. It is React itself
-     * who contains the "special handling".
-     *
-     * So we can safely re-use this digest to make sure that the error is not
-     * reported by Next.js
-     */
-    readonly digest = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+declare const needLogin: (message: string) => never;
+declare const isNeedLoginError: (error: unknown) => error is __factory.SekishoGuardError;
+declare const NotAuthenticatedError: new (message: string) => __factory.SekishoGuardError;
+
+interface NotAuthenticatedErrorWrapperProps extends React.PropsWithChildren {
+    error: unknown | null | undefined;
 }
-declare function isNeedLoginError(error: unknown): error is NotAuthenticatedError;
+/** @deprecated `SekishoErrorWrapperProps` has since been renamed to `NotAuthenticatedErrorWrapperProps` */
+type SekishoErrorWrapperProps = NotAuthenticatedErrorWrapperProps;
 /**
- * Throw a `NotAuthenticatedError` from anywhere in the React render phase.
- *
- * The error is caught by the nearest `SekishoErrorWrapper` or
- * `SekishoErrorBoundary`, which then calls the `onNeedLogin` callback supplied
- * to `SekishoProvider`.
+ * The actual error handling and redirection logic for "Not Authenticated" error.
  *
- * Common call sites: ky afterResponse hooks (HTTP 401), SWR middleware, or
- * directly inside a component when session state is absent.
+ * Used internally by `NotAuthenticatedBoundary`. You can also use this directly in
+ * a Next.js `app/error.tsx` file for custom error handling.
  */
-declare function needLogin(message: string): never;
+declare function NotAuthenticatedErrorWrapper({ error, children }: NotAuthenticatedErrorWrapperProps): react.ReactNode;
 
-interface SekishoErrorWrapperProps extends React.PropsWithChildren {
-    error: unknown | null | undefined;
+interface NotAuthenticatedBoundaryProps extends React.PropsWithChildren {
 }
 /**
- * The actual error handling and redirection logic for "Not Authenticated" error
+ * Error boundary that catches `NotAuthenticatedError` thrown by `needLogin()`
+ * within its subtree and calls the `onNeedLogin` callback from `SekishoProvider`.
+ * All other errors are re-thrown to the next boundary up the tree.
  *
- * This is used internally by SekishoErrorBoundary. And if you are using Next.js App Router,
- * you can use this directly in the "error.tsx" file.
+ * This is included inside `SekishoProvider` automatically; you only need to use
+ * it directly if you want a narrower boundary for a specific subtree.
  */
-declare function SekishoErrorWrapper({ error, children }: SekishoErrorWrapperProps): react.ReactNode;
-
-interface SekishoErrorBoundaryProps extends React.PropsWithChildren {
-}
-interface SekishoErrorBoundaryState {
-    needLoginErrorObject: unknown | null | undefined;
-}
-declare class SekishoErrorBoundary extends Component<SekishoErrorBoundaryProps, SekishoErrorBoundaryState> {
-    constructor(props: SekishoErrorBoundaryProps);
-    static getDerivedStateFromError(this: void, error: unknown): SekishoErrorBoundaryState;
-    render(): React.ReactNode;
-}
+declare function NotAuthenticatedBoundary({ children }: NotAuthenticatedBoundaryProps): React.ReactNode;
+/** @deprecated `SekishoErrorBoundaryProps` has since been renamed to `NotAuthenticatedBoundaryProps` */
+type SekishoErrorBoundaryProps = NotAuthenticatedBoundaryProps;
 
 interface SekishoOptions {
     onNeedLogin: () => void;
@@ -68,55 +43,15 @@ interface SekishoProviderProps extends React.PropsWithChildren, SekishoOptions {
 }
 declare function SekishoProvider({ children, ...auth }: SekishoProviderProps): react_jsx_runtime.JSX.Element;
 
-declare class AccessRestrictedError extends Error {
-    readonly name = "AccessRestrictedError";
-    readonly accessRestricted = true;
-    readonly $sekishoError = true;
-    /**
-     * Normally, when React encounters an error during rendering in the server,
-     * it will find the nearest Suspense boundary and render its fallback (on
-     * the client it would find the nearest error boundary instead).
-     *
-     * For various purposes, Next.js also uses this mechanism to bail out of
-     * server-side rendering to do client-side rendering only. Thus Next.js
-     * create this magic digest 'BAILOUT_TO_CLIENT_SIDE_RENDERING' that does
-     * nothing but allow every error report (console, reportError, etc.) to
-     * skip this error
-     *
-     * Next.js doesn't handle this error in any special way. It is React itself
-     * who contains the "special handling".
-     *
-     * So we can safely re-use this digest to make sure that the error is not
-     * reported by Next.js
-     */
-    readonly digest = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
-}
-declare function isAccessRestrictedError(error: unknown): error is AccessRestrictedError;
-/**
- * Throw an `AccessRestrictedError` from anywhere in the React render phase.
- *
- * The error is caught by the nearest `SekishoAccessContainer`, which renders
- * its `fallback` prop instead of its children. Any other error boundary in the
- * tree (including `SekishoErrorBoundary`) re-throws it unchanged.
- */
-declare function accessRestricted(message: string): never;
-
-interface SekishoAccessContainerProps extends React.PropsWithChildren {
-    fallback: React.ReactNode;
-}
-interface State {
-    restricted: boolean;
-}
-/**
- * Error boundary that catches `AccessRestrictedError` thrown by
- * `accessRestricted()` within its subtree and renders `fallback` in place of
- * `children`. All other errors are re-thrown to the next boundary up the tree.
- */
-declare class SekishoAccessContainer extends Component<SekishoAccessContainerProps, State> {
-    constructor(props: SekishoAccessContainerProps);
-    static getDerivedStateFromError(this: void, error: unknown): State;
-    render(): React.ReactNode;
-}
-
-export { AccessRestrictedError, NotAuthenticatedError, SekishoAccessContainer, SekishoErrorBoundary, SekishoErrorWrapper, SekishoProvider, accessRestricted, isAccessRestrictedError, isNeedLoginError, needLogin };
-export type { SekishoAccessContainerProps, SekishoErrorBoundaryProps, SekishoErrorWrapperProps, SekishoOptions, SekishoProviderProps };
+declare const accessRestricted: (message: string) => never;
+declare const AccessRestrictedContainer: react.ComponentClass<SekishoGuardBoundaryProps, __factory.SekishoGuardBoundaryState>;
+declare const isAccessRestrictedError: (error: unknown) => error is __factory.SekishoGuardError;
+declare const AccessRestrictedError: new (message: string) => __factory.SekishoGuardError;
+type AccessRestrictedContainerProps = SekishoGuardBoundaryProps;
+/** @deprecated `SekishoAccessContainer` has since been renamed to `AccessRestrictedContainer` */
+declare const SekishoAccessContainer: react.ComponentClass<SekishoGuardBoundaryProps, __factory.SekishoGuardBoundaryState>;
+/** @deprecated `SekishoAccessContainerProps` has since been renamed to `AccessRestrictedContainerProps` */
+type SekishoAccessContainerProps = AccessRestrictedContainerProps;
+
+export { AccessRestrictedContainer, AccessRestrictedError, NotAuthenticatedBoundary, NotAuthenticatedError, NotAuthenticatedErrorWrapper, SekishoAccessContainer, NotAuthenticatedBoundary as SekishoErrorBoundary, NotAuthenticatedErrorWrapper as SekishoErrorWrapper, SekishoProvider, accessRestricted, isAccessRestrictedError, isNeedLoginError, needLogin };
+export type { AccessRestrictedContainerProps, NotAuthenticatedBoundaryProps, NotAuthenticatedErrorWrapperProps, SekishoAccessContainerProps, SekishoErrorBoundaryProps, SekishoErrorWrapperProps, SekishoOptions, SekishoProviderProps };

package/dist/index.mjs

@@ -1 +1 @@
-"use client";import{createStacklessError as r}from"foxact/create-stackless-error";import{useLayoutEffect as e}from"foxact/use-isomorphic-layout-effect";import{nullthrow as t}from"foxact/nullthrow";import{createContext as o,useContext as s,Component as i}from"react";import{useStableHandler as n}from"foxact/use-stable-handler-only-when-you-know-what-you-are-doing-or-you-will-be-fired";import{jsx as c}from"react/jsx-runtime";class h extends Error{constructor(...r){super(...r),this.name="NotAuthenticatedError",this.notAuthenticated=!0,this.$sekishoError=!0,this.digest="BAILOUT_TO_CLIENT_SIDE_RENDERING"}}function d(r){return!!r&&"object"==typeof r&&"notAuthenticated"in r&&!0===r.notAuthenticated&&"$sekishoError"in r&&!0===r.$sekishoError}function a(e){throw r(()=>new h(e))}let u=o(null);function l({error:r,children:o}){let{onNeedLogin:i}=t(s(u),"useSekishoOptions must be used within a SekishoOptionsProvider"),c=d(r),h=n(i);return(e(()=>{c&&h()},[c,h]),c)?null:o}class E extends i{constructor(r){super(r),this.state={needLoginErrorObject:null}}static getDerivedStateFromError(r){if(d(r))return{needLoginErrorObject:r};throw r}render(){return this.state.needLoginErrorObject?c(l,{error:this.state.needLoginErrorObject,children:this.props.children}):this.props.children}}function p({children:r,...e}){return c(u.Provider,{value:e,children:c(E,{children:r})})}class f extends Error{constructor(...r){super(...r),this.name="AccessRestrictedError",this.accessRestricted=!0,this.$sekishoError=!0,this.digest="BAILOUT_TO_CLIENT_SIDE_RENDERING"}}function m(r){return!!r&&"object"==typeof r&&"accessRestricted"in r&&!0===r.accessRestricted&&"$sekishoError"in r&&!0===r.$sekishoError}function k(e){throw r(()=>new f(e))}class w extends i{constructor(r){super(r),this.state={restricted:!1}}static getDerivedStateFromError(r){if(m(r))return{restricted:!0};throw r}render(){return this.state.restricted?this.props.fallback:this.props.children}}export{f as AccessRestrictedError,h as NotAuthenticatedError,w as SekishoAccessContainer,E as SekishoErrorBoundary,l as SekishoErrorWrapper,p as SekishoProvider,k as accessRestricted,m as isAccessRestrictedError,d as isNeedLoginError,a as needLogin};
+"use client";import{jsx as r}from"react/jsx-runtime";import{useLayoutEffect as e}from"foxact/use-isomorphic-layout-effect";import{useStableHandler as t}from"foxact/use-stable-handler-only-when-you-know-what-you-are-doing-or-you-will-be-fired";import{createSekisho as o}from"./factory.mjs";export{createSekisho}from"./factory.mjs";import{nullthrow as i}from"foxact/nullthrow";import{createContext as n,useContext as c}from"react";let s=n(null),[a,u,d,h]=o("NotAuthenticatedError");function l({error:r,children:o}){let{onNeedLogin:n}=i(c(s),"useSekishoOptions must be used within a SekishoOptionsProvider"),a=d(r),u=t(n);return(e(()=>{a&&u()},[a,u]),a)?null:o}function f({children:e}){return r(u,{fallbackComponent:l,children:e})}function m({children:e,...t}){return r(s.Provider,{value:t,children:r(f,{children:e})})}let[p,A,y,E]=o("AccessRestrictedError"),k=A;export{A as AccessRestrictedContainer,E as AccessRestrictedError,f as NotAuthenticatedBoundary,h as NotAuthenticatedError,l as NotAuthenticatedErrorWrapper,k as SekishoAccessContainer,f as SekishoErrorBoundary,l as SekishoErrorWrapper,m as SekishoProvider,p as accessRestricted,y as isAccessRestrictedError,d as isNeedLoginError,a as needLogin};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sekisho",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Authentication and Access Control for any React app",
   "repository": {
     "type": "git",
@@ -21,6 +21,12 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
+    "./factory": {
+      "types": "./dist/factory.d.ts",
+      "import": "./dist/factory.mjs",
+      "require": "./dist/factory.cjs",
+      "default": "./dist/factory.cjs"
+    },
     "./package.json": "./package.json"
   },
   "author": "Sukka <https://skk.moe>",
@@ -29,7 +35,7 @@
     "foxact": "^0.3.1"
   },
   "devDependencies": {
-    "@swc/core": "^1.15.32",
+    "@swc/core": "^1.15.33",
     "@types/react": "^19.2.14",
     "bunchee": "^6.10.0"
   },