@securitydept/client-react 0.3.0-beta.1 → 0.3.0-beta.10

package/README.md

@@ -2,4 +2,10 @@
 
 Client React of the SecurityDept TypeScript SDK, a layered authentication and authorization toolkit built as reusable Rust crates, a TypeScript client SDK workspace, and reference server/web apps.
 
+## Documentation
+
+- [Package documentation](https://www.npmjs.com/package/@securitydept/client-react)
+- [SecurityDept TypeScript SDK guide](https://github.com/ethaxon/securitydept/blob/main/docs/en/007-CLIENT_SDK_GUIDE.md)
+- [SecurityDept architecture](https://github.com/ethaxon/securitydept/blob/main/docs/en/001-ARCHITECTURE.md)
+
 Repository: [ethaxon/securitydept](https://github.com/ethaxon/securitydept)

package/dist/index.d.mts

@@ -1,88 +1,105 @@
-import { AuthGuardClientOption, CandidateSelector, PlannerHost, ScopedRequirementsClientSet, resolveEffectiveClientSet } from "@securitydept/client/auth-coordination";
-import { ReactNode } from "react";
-import * as _$react_jsx_runtime0 from "react/jsx-runtime";
-
-//#region src/planner-host/index.d.ts
-/** Props for {@link AuthPlannerHostProvider}. */
-interface AuthPlannerHostProviderProps {
-  /**
-   * Custom candidate selection strategy.
-   * @see {@link CandidateSelector}
-   */
-  selectCandidate?: CandidateSelector;
-  /**
-   * Pre-constructed PlannerHost instance to use.
-   * If provided, `selectCandidate` is ignored.
-   */
-  plannerHost?: PlannerHost;
-  children: ReactNode;
+import { CreateFoundationEnvironmentOptions, DisposableTrait, EventStreamTrait, FoundationEnvironment, InteropObservableTrait, ReadableSignalTrait, ResourceSnapshot, ResourceTrait, SYMBOL_DISPOSE, SecuritydeptInjectorTrait, SecuritydeptProvider as SecuritydeptProvider$1, SubscribableTrait, TimeTrait } from "@securitydept/client";
+import { DependencyList, ReactNode, RefObject } from "react";
+//#region src/environment.d.ts
+type ReactEnvironmentCreatorOptions = {
+  providers?: readonly SecuritydeptProvider$1[];
+};
+type ReactEnvironmentCreator<TOptions extends ReactEnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment> = (options: TOptions) => TEnvironment;
+interface CreateEnvironmentForReactOptions extends CreateFoundationEnvironmentOptions {}
+type CreateEnvironmentForReactWithBaseOptions<TBaseOptions extends ReactEnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment> = Omit<TBaseOptions, "providers" | "createBaseEnvironment"> & {
+  createBaseEnvironment: ReactEnvironmentCreator<TBaseOptions, TEnvironment>;
+  providers?: readonly SecuritydeptProvider$1[];
+};
+declare function createEnvironmentForReact(): FoundationEnvironment;
+declare function createEnvironmentForReact(options: CreateEnvironmentForReactOptions): FoundationEnvironment;
+declare function createEnvironmentForReact<TBaseOptions extends ReactEnvironmentCreatorOptions, TEnvironment extends FoundationEnvironment>(options: CreateEnvironmentForReactWithBaseOptions<TBaseOptions, TEnvironment>): TEnvironment;
+//#endregion
+//#region src/hooks/use-initial-ref.d.ts
+declare function useInitialRef<T>(initialize: () => T): RefObject<T>;
+//#endregion
+//#region src/injection/index.d.ts
+declare const SecuritydeptContext: import("react").Context<any>;
+interface SecuritydeptProviderProps {
+  readonly injector: SecuritydeptInjectorTrait;
+  readonly children?: ReactNode;
+}
+declare function SecuritydeptProvider({ injector, children }: SecuritydeptProviderProps): import("react").JSX.Element;
+declare function useSecuritydeptContext(): SecuritydeptInjectorTrait;
+//#endregion
+//#region src/interop.d.ts
+declare function useSignal<T>(source: ReadableSignalTrait<T>): T;
+declare function useResourceSnapshot<T>(resource: ResourceTrait<T>): ResourceSnapshot<T>;
+declare function useResourceSnapshot<T>(snapshot: ReadableSignalTrait<ResourceSnapshot<T>>): ResourceSnapshot<T>;
+declare function useResourceSnapshot<T>(compute: () => ResourceSnapshot<T>, dependencies: DependencyList): ResourceSnapshot<T>;
+interface UseInteropObservableOptions<T> {
+  initialValue?: T;
+  requireSync?: boolean;
+}
+declare function useInteropObservable<T>(source: InteropObservableTrait<T> | SubscribableTrait<T>): T | undefined;
+declare function useInteropObservable<T>(source: InteropObservableTrait<T> | SubscribableTrait<T>, options: UseInteropObservableOptions<T> & {
+  initialValue?: undefined;
+  requireSync?: false;
+}): T | undefined;
+declare function useInteropObservable<T>(source: InteropObservableTrait<T> | SubscribableTrait<T>, options: UseInteropObservableOptions<T | null> & {
+  initialValue?: null;
+  requireSync?: false;
+}): T | null;
+declare function useInteropObservable<T>(source: InteropObservableTrait<T> | SubscribableTrait<T>, options: UseInteropObservableOptions<T> & {
+  initialValue?: undefined;
+  requireSync: true;
+}): T;
+declare function useInteropObservable<T, const U extends T>(source: InteropObservableTrait<T> | SubscribableTrait<T>, options: UseInteropObservableOptions<T | U> & {
+  initialValue: U;
+  requireSync?: false;
+}): T | U;
+declare function useEventStream<T>(source: EventStreamTrait<T>, handler: (event: T) => void, options?: {
+  enabled?: boolean;
+}): void;
+//#endregion
+//#region src/query-store.d.ts
+type QueryStoreKeyValue = null | boolean | number | string | readonly QueryStoreKeyValue[] | {
+  readonly [key: string]: QueryStoreKeyValue;
+};
+type QueryStoreKey = readonly QueryStoreKeyValue[];
+interface QueryStoreOptions {
+  readonly time: TimeTrait;
+  readonly gcTimeMs?: number;
+}
+interface ProvideQueryStoreOptions {
+  readonly gcTimeMs?: number;
+}
+declare class QueryStore implements DisposableTrait {
+  [SYMBOL_DISPOSE]: () => void;
+  static readonly defaultOptions: Readonly<{
+    gcTimeMs: 300000;
+  }>;
+  private readonly queries;
+  private readonly weakKeyIds;
+  private readonly scheduler;
+  private readonly gcTimeMs;
+  private nextWeakKeyId;
+  private disposed;
+  constructor(options: QueryStoreOptions);
+  getWeakKeyId(value: object): string;
+  dispose(): void;
+  private removeQuery;
+}
+declare function provideQueryStore(options?: ProvideQueryStoreOptions): readonly SecuritydeptProvider$1[];
+declare function useQueryStore(): QueryStore;
+//#endregion
+//#region src/suspense-resource.d.ts
+interface UseSuspenseResourceValueOptions {
+  readonly queryKey?: QueryStoreKey;
+  readonly gcTimeMs?: number;
+  readonly retainWhilePending?: boolean;
 }
-/**
- * Provide a {@link PlannerHost} at the current React tree scope.
- *
- * Use at the app level or at feature-route boundaries to establish
- * planner-host scopes. Child components inherit the nearest provider.
- *
- * @example
- * ```tsx
- * // App-level (default sequential strategy)
- * <AuthPlannerHostProvider>
- *   <App />
- * </AuthPlannerHostProvider>
- *
- * // Feature-route with custom chooser
- * <AuthPlannerHostProvider selectCandidate={showChooser}>
- *   <FeatureRoutes />
- * </AuthPlannerHostProvider>
- * ```
- */
-declare function AuthPlannerHostProvider({
-  selectCandidate,
-  plannerHost,
-  children
-}: AuthPlannerHostProviderProps): _$react_jsx_runtime0.JSX.Element;
-/**
- * Look up the nearest {@link PlannerHost} from the React Context tree.
- *
- * Throws an explicit error if no provider is found, preventing
- * silent fallback behavior.
- */
-declare function useAuthPlannerHost(): PlannerHost;
-/** Props for {@link AuthRequirementsClientSetProvider}. */
-interface AuthRequirementsClientSetProviderProps {
-  /** The scoped set to provide at this level. */
-  scopedSet: ScopedRequirementsClientSet;
-  children: ReactNode;
+interface UseSuspenseComputedResourceValueOptions extends Omit<UseSuspenseResourceValueOptions, "queryKey"> {
+  readonly dependencies: DependencyList;
+  readonly queryKey: QueryStoreKey;
 }
-/**
- * Provide a {@link ScopedRequirementsClientSet} at the current React tree scope.
- *
- * Automatically resolves the effective client set by composing with the
- * parent scope's options according to the declared composition strategy.
- *
- * @example
- * ```tsx
- * // Feature route: merge OIDC requirement with parent's session requirement
- * <AuthRequirementsClientSetProvider
- *   scopedSet={{
- *     composition: RequirementsClientSetComposition.Merge,
- *     options: [oidcClientOption],
- *   }}
- * >
- *   <ProtectedFeature />
- * </AuthRequirementsClientSetProvider>
- * ```
- */
-declare function AuthRequirementsClientSetProvider({
-  scopedSet,
-  children
-}: AuthRequirementsClientSetProviderProps): _$react_jsx_runtime0.JSX.Element;
-/**
- * Get the effective requirements client set for the current React tree scope.
- *
- * Returns the resolved options after applying all parent/child composition.
- */
-declare function useEffectiveClientSet(): readonly AuthGuardClientOption[];
+declare function useSuspenseResourceValue<T>(resource: ResourceTrait<T>, options?: UseSuspenseResourceValueOptions): T;
+declare function useSuspenseResourceValue<T>(snapshot: ReadableSignalTrait<ResourceSnapshot<T>>, options?: UseSuspenseResourceValueOptions): T;
+declare function useSuspenseResourceValue<T>(compute: () => ResourceSnapshot<T>, options: UseSuspenseComputedResourceValueOptions): T;
 //#endregion
-export { AuthPlannerHostProvider, AuthPlannerHostProviderProps, AuthRequirementsClientSetProvider, AuthRequirementsClientSetProviderProps, resolveEffectiveClientSet, useAuthPlannerHost, useEffectiveClientSet };
+export { CreateEnvironmentForReactOptions, CreateEnvironmentForReactWithBaseOptions, type ProvideQueryStoreOptions, QueryStore, type QueryStoreKey, type QueryStoreKeyValue, type QueryStoreOptions, ReactEnvironmentCreator, ReactEnvironmentCreatorOptions, SecuritydeptContext, SecuritydeptProvider, SecuritydeptProviderProps, UseInteropObservableOptions, type UseSuspenseComputedResourceValueOptions, type UseSuspenseResourceValueOptions, createEnvironmentForReact, provideQueryStore, useEventStream, useInitialRef, useInteropObservable, useQueryStore, useResourceSnapshot, useSecuritydeptContext, useSignal, useSuspenseResourceValue };
 //# sourceMappingURL=index.d.mts.map