permdock 0.0.0 → 0.2.0

package/dist/react/provider-client.js

@@ -0,0 +1,3 @@
+"use client";
+import { t as PermDockProvider } from "../provider-DLzpb2Xz.js";
+export { PermDockProvider };

package/dist/react-native/index.d.ts

@@ -0,0 +1,198 @@
+import { At as SnapshotSource, Dr as CustomRole, Ft as TokenVerifier, Mr as Membership, Tt as Snapshot, pt as LocalSnapshotManifest } from "../policy-CFZAr_Al.js";
+import { f as Permission } from "../permissions-DttnqqxC.js";
+import { n as requiredPlans } from "../problem-details-CkL50EEf.js";
+import { i as describe } from "../describe-PdoqESvg.js";
+import { t as parseLocalSnapshotManifest } from "../parse-local-manifest-BkGQNzAh.js";
+import { t as approvalHeaders } from "../headers-Cf-zWvsO.js";
+import { a as FilterResult, c as SubjectView, i as ClientStatus, l as TenantView, n as ApprovalState, o as PermissionSet, r as ClientPermDock, s as PermissionState, t as ApprovalHandle } from "../types-kxznc7cn.js";
+import { n as ProtectedProps } from "../types-C3s9xVJG.js";
+import { a as useFilter, c as usePermission, d as useSubject, f as useTenant, i as useAssignableRoles, l as usePermissions, n as useApproval, o as useMemberships, r as useAssignablePermissions, s as usePermDock, t as Protected, u as useRoles } from "../protected-CNsMzrVd.js";
+import { t as ClientStore } from "../store-D_pjn91-.js";
+import { ReactElement, ReactNode } from "react";
+//#region src/react-native/guards.d.ts
+/** `true` once the provider has a snapshot to answer from: storage was read or a seed was given. Hide the splash screen on it. */
+export declare function useSnapshotReady(): boolean;
+/**
+ * A boolean for `Stack.Protected` and `Tabs.Protected`: `false` while the
+ * snapshot is pending, `true` only when every permission is allowed for
+ * `data`.
+ */
+export declare function usePermissionGuard(permission: Permission | readonly Permission[], data?: unknown): boolean;
+//#endregion
+//#region src/react-native/local.d.ts
+/** What the device holds for the signed-in user, read from its local database. */
+type LocalSnapshotData = {
+  readonly principal: {
+    readonly id: string;
+    /** Global roles, declared or platform custom roles. */
+    readonly roles?: readonly string[];
+    readonly plans?: readonly string[];
+    /** The active tenant: the first scope's instance the UI shows. */
+    readonly tenant?: string;
+    readonly memberships?: readonly Membership[];
+    /** Attributes conditions read, such as `claims` for `principal.claims.team_ids`. */
+    readonly attributes?: Readonly<Record<string, unknown>>;
+  } | null;
+  /** The tenant's custom roles, in the shape a `RoleSource` returns. */
+  readonly customRoles?: readonly CustomRole[];
+};
+type LocalSnapshotOptions = {
+  /** `localSnapshotManifest(policy)`, written at build time. */
+  readonly manifest: LocalSnapshotManifest;
+  readonly read: () => LocalSnapshotData | Promise<LocalSnapshotData>;
+  /** Calls the listener when the rows `read` reads change; returns the unsubscribe. */
+  readonly subscribe?: (listener: () => void) => () => void;
+};
+/**
+ * The snapshot a server would send for `data`, built from the manifest. It
+ * drives UI guards only: the server still decides every request.
+ */
+export declare function buildLocalSnapshot(manifest: LocalSnapshotManifest, data: LocalSnapshotData, now?: number): Snapshot;
+/**
+ * A snapshot source over the device's own membership rows (SQLite, a
+ * PowerSync or Electric replica): offline, the UI guards answer from them.
+ */
+export declare function localSnapshot(options: LocalSnapshotOptions): SnapshotSource;
+//#endregion
+//#region src/react-native/powersync.d.ts
+/** The `PowerSyncDatabase` methods `powersyncSource` calls. */
+type PowerSyncWatchable = {
+  getAll(sql: string, parameters?: unknown[]): Promise<unknown[]>;
+  watch(sql: string, parameters: unknown[] | undefined, handler: {
+    onResult(result: unknown): void;
+    onError?(error: Error): void;
+  }, options: {
+    readonly signal: AbortSignal;
+  }): void;
+};
+/** One local query: SQL over the synced tables and its parameters. */
+type PowerSyncQuery = {
+  readonly sql: string;
+  readonly parameters?: readonly unknown[];
+};
+type PowerSyncSourceOptions<Q extends string> = {
+  /** `localSnapshotManifest(policy)`, as `permdock powersync generate` writes it to `powersync.manifest`. */
+  readonly manifest: LocalSnapshotManifest;
+  /** The queries over the `permdock_*` streams' tables; each one is watched. */
+  readonly queries: Readonly<Record<Q, PowerSyncQuery>>;
+  /** Maps the rows of each query to the signed-in user's memberships and roles. */
+  readonly read: (rows: Readonly<Record<Q, readonly unknown[]>>) => LocalSnapshotData;
+};
+/**
+ * A `localSnapshot` source over a PowerSync database: `get` runs every query
+ * with `db.getAll`, and a `db.watch` per query reports changes. A watch
+ * result with unchanged content re-renders nothing (`connectSource`). The source
+ * takes the database as an argument; `permdock/react-native` never imports
+ * `@powersync/*`.
+ */
+export declare function powersyncSource<Q extends string>(db: PowerSyncWatchable, options: PowerSyncSourceOptions<Q>): SnapshotSource;
+//#endregion
+//#region src/react-native/types.d.ts
+type PermDockStorage = {
+  getItem(key: string): string | null | Promise<string | null>;
+  setItem(key: string, value: string): void | Promise<void>;
+  removeItem(key: string): void | Promise<void>;
+};
+type NativeRevalidate = "launch" | "focus" | number;
+/**
+ * Calls `listener` when the app changes state; `active` is `false` when it
+ * goes to the background. A listener called without an argument counts as
+ * a return to the foreground.
+ */
+type SubscribeForeground = (listener: (active?: boolean) => void) => () => void;
+/** Calls `listener` with `false` when the device loses connectivity and `true` when it returns. */
+type SubscribeOnline = (listener: (online: boolean) => void) => () => void;
+type NativePermDockProviderProps = {
+  readonly storage: PermDockStorage;
+  /**
+   * The signed-in principal's id, or `null` when nobody is signed in. Only a
+   * persisted snapshot for this id is read or written; `null` clears storage.
+   */
+  readonly subjectId: string | null;
+  readonly snapshot?: Snapshot | string;
+  readonly snapshotUrl?: string;
+  /** Hydrates from the device's own rows (`localSnapshot`); with `snapshotUrl` too, the latest answer wins. */
+  readonly source?: SnapshotSource;
+  readonly endpoint?: string;
+  readonly approvals?: string;
+  readonly tenant?: string;
+  readonly revalidate?: NativeRevalidate;
+  readonly subscribeForeground?: SubscribeForeground;
+  readonly subscribeOnline?: SubscribeOnline;
+  readonly fetch?: typeof fetch;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly maxAge?: number;
+  readonly verifier?: TokenVerifier;
+  readonly children: ReactNode;
+};
+//#endregion
+//#region src/react-native/provider.d.ts
+export declare function PermDockProvider(props: NativePermDockProviderProps): ReactElement;
+//#endregion
+//#region src/react-native/storage.d.ts
+export declare function memoryStorage(initial?: Readonly<Record<string, string>>): PermDockStorage;
+//#endregion
+//#region src/react-native/storage-adapters.d.ts
+/** The `expo-secure-store` functions `secureStoreStorage` calls. */
+type SecureStoreModule = {
+  getItem(key: string, options?: object): string | null;
+  setItem(key: string, value: string, options?: object): void;
+  deleteItemAsync(key: string, options?: object): Promise<void>;
+};
+/** The `react-native-mmkv` instance methods `mmkvStorage` calls: `remove` (v4) or `delete` (v3). */
+type MmkvInstance = {
+  getString(key: string): string | undefined;
+  set(key: string, value: string): void;
+} & ({
+  remove(key: string): unknown;
+} | {
+  delete(key: string): unknown;
+});
+/**
+ * A `PermDockStorage` over `expo-secure-store`. Values are split into chunks
+ * of at most 2048 bytes under `<key>.<n>`; `<key>` holds the chunk count and
+ * is written last, so an interrupted write reads as absent.
+ */
+export declare function secureStoreStorage(store: SecureStoreModule, options?: object): PermDockStorage;
+/** A synchronous `PermDockStorage` over a `react-native-mmkv` instance: the first frame already has the snapshot. */
+export declare function mmkvStorage(mmkv: MmkvInstance): PermDockStorage;
+//#endregion
+//#region src/react-native/subscriptions.d.ts
+/** The `AppState` export of `react-native`, as `appStateForeground` calls it. */
+type AppStateModule = {
+  addEventListener(type: "change", listener: (state: string) => void): {
+    remove(): void;
+  };
+};
+/** The default export of `@react-native-community/netinfo`, as `netInfoOnline` calls it. */
+type NetInfoModule = {
+  addEventListener(listener: (state: {
+    readonly isConnected: boolean | null;
+    readonly isInternetReachable?: boolean | null;
+  }) => void): () => void;
+};
+/**
+ * `subscribeForeground` over `AppState`: `active` returns to the foreground
+ * and `background` leaves it. iOS `inactive` (a system sheet over the app) is
+ * neither.
+ */
+export declare function appStateForeground(appState: AppStateModule): SubscribeForeground;
+/** `subscribeOnline` over NetInfo. An unknown (`null`) connection counts as online. */
+export declare function netInfoOnline(netInfo: NetInfoModule): SubscribeOnline;
+//#endregion
+//#region src/react-native/store.d.ts
+type NativeStoreOptions = Omit<NativePermDockProviderProps, "children" | "headers"> & {
+  readonly headers?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>> | undefined);
+  /** A store this one replaces: its snapshot and tenant seed this store, so guards do not flip while it boots. */
+  readonly previous?: ClientStore;
+};
+/**
+ * Hydrates `store` from `source` now, on every change it reports and on each
+ * return to the foreground. Only the latest read applies; a read with
+ * unchanged content re-renders nothing, and a failed read keeps the current
+ * snapshot. Returns the unsubscribe.
+ */
+export declare function connectSource(store: ClientStore, source: SnapshotSource, subscribeForeground?: SubscribeForeground): () => void;
+export declare function createNativeStore(options: NativeStoreOptions): ClientStore;
+//#endregion
+export { type AppStateModule, type ApprovalHandle, type ApprovalState, type ClientPermDock, type ClientStatus, type FilterResult, type LocalSnapshotData, type LocalSnapshotManifest, type LocalSnapshotOptions, type MmkvInstance, type NativePermDockProviderProps, type NativeRevalidate, type NetInfoModule, type PermDockStorage, type PermissionSet, type PermissionState, type PowerSyncQuery, type PowerSyncSourceOptions, type PowerSyncWatchable, Protected, type ProtectedProps, type SecureStoreModule, type SnapshotSource, type SubjectView, type SubscribeForeground, type SubscribeOnline, type TenantView, approvalHeaders, describe, parseLocalSnapshotManifest, requiredPlans, useApproval, useAssignablePermissions, useAssignableRoles, useFilter, useMemberships, usePermDock, usePermission, usePermissions, useRoles, useSubject, useTenant };