@archont561/qgis-sdk 0.3.0 → 0.5.0

package/dist/react.d.ts

@@ -1,116 +1,26 @@
+import { WireTransport2, BridgeClientOptions2, BridgeClient2 } from "./shared/chunk-wtv4vt4q.js";
+import "./shared/chunk-7tgzmz0m.js";
+import { OperationMap2, StreamMap2, QgisSdkCore2, QgisSdk2 } from "./shared/chunk-a33y575v.js";
+import { Store2, OperationState2, Operation2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, FormState2, FormOptions2, FormStore2, HostQueryState2, HostQueryStore2 } from "./shared/chunk-3zscfm3y.js";
+import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
 import { ReactElement, ReactNode } from "react";
-/**
-* Base class for expected SDK errors across the bridge boundary.
-*/
-declare class QgisSdkError extends Error {
-	readonly code: string;
-	constructor(message: string, code?: string);
-}
-/** The kinds of event a stream may carry; only `progress` may be coalesced. */
-type StreamEventKind2 = "data" | "progress" | "state";
-/** Why a subscription stopped. */
-type StreamTerminalKind = "complete" | "error" | "cancelled" | "gap" | "disposed";
-/** One event on a subscription. */
-interface BridgeStreamEvent {
-	readonly kind: StreamEventKind2;
-	readonly payload: unknown;
-}
-/** The end of a subscription, as the host described it. */
-interface BridgeStreamTerminal {
-	readonly kind: StreamTerminalKind;
-	readonly message?: string;
-	readonly dropped?: number;
-}
-/** The transport a client speaks through; a QWebChannel adapter or a script. */
-interface WireTransport {
-	send(message: unknown): void;
-	subscribe(listener: (message: unknown) => void): () => void;
-}
-/** Options for {@link BridgeClient}. */
-interface BridgeClientOptions {
-	readonly timeoutMs?: number;
-}
-/** Options for one invocation. */
-interface InvokeOptions {
-	readonly signal?: AbortSignal;
-}
-/** Callbacks a subscription reports through. */
-interface SubscriptionHandlers {
-	readonly onEvent?: (event: BridgeStreamEvent) => void;
-	readonly onTerminal?: (terminal: BridgeStreamTerminal) => void;
-}
-/** A live subscription, as the caller holds it. */
-interface BridgeSubscription {
-	readonly id: string;
-	readonly closed: boolean;
-	close(): void;
-}
-/**
-* Correlate invocations with replies over an injected transport.
-*
-* The client never retries: a timeout, an abort and a closed client are three
-* different answers, and each is reported as itself.
-*/
-declare class BridgeClient {
-	private readonly transport;
-	private readonly timeoutMs;
-	private readonly pending;
-	private readonly subscriptions;
-	private readonly disposals;
-	private readonly unsubscribe;
-	private counter;
-	private closed;
-	private unmatched;
-	private breaks;
-	private lastProtocolError;
-	constructor(transport: WireTransport, options?: BridgeClientOptions);
-	/** Whether {@link close} has run; a closed client answers nothing. */
-	get isClosed(): boolean;
-	/** Replies that named no pending call: a late duplicate, or a stray message. */
-	get unmatchedReplies(): number;
-	/** Number of calls still waiting for a reply. */
-	get pendingCalls(): number;
-	/**
-	* Invoke one operation and settle with its value or with a typed failure.
-	*/
-	invoke(operation: string, payload?: Readonly<Record<string, unknown>>, options?: InvokeOptions): Promise<unknown>;
-	/**
-	* Open a subscription and resolve once the host has acknowledged it.
-	*
-	* Frames are matched to the subscription by id and by sequence; a frame that
-	* does not continue the sequence ends the subscription instead of being
-	* delivered out of order.
-	*/
-	subscribe(operation: string, payload?: Readonly<Record<string, unknown>>, handlers?: SubscriptionHandlers, options?: InvokeOptions): Promise<BridgeSubscription>;
-	/** Subscriptions still open; a leak check for callers and tests. */
-	get activeSubscriptions(): readonly string[];
-	/** Frames that did not continue their subscription's sequence. */
-	get sequenceBreaks(): number;
-	private send;
-	/**
-	* Refuse further calls, reject what is still pending, and stop listening.
-	*/
-	close(): void;
-	private settle;
-	private handle;
-	private handleFrame;
-	private endSubscription;
-	private disposeSubscription;
-	/** The last malformed message this client refused, if any. */
-	get protocolError(): Error | null;
-}
 /** A hook or provider was used outside the shape it needs. */
-declare class QgisSdkBridgeReactError extends QgisSdkError {
+declare class QgisSdkBridgeReactError extends QgisSdkError2 {
 	constructor(message: string);
 }
-/** Props for {@link BridgeProvider}: exactly one of `client` or `transport`. */
+/** Props for {@link BridgeProvider}: exactly one of `qgis`, `client` or `transport`. */
 interface BridgeProviderProps {
+	/**
+	* A `QgisSdk` the page built, whatever its schema; the provider shares it
+	* and never closes it. `useQgisSdk` hands it back under the page's types.
+	*/
+	readonly qgis?: QgisSdkCore2<unknown, unknown>;
 	/** A client the caller owns; the provider never closes it. */
-	readonly client?: BridgeClient;
+	readonly client?: BridgeClient2;
 	/** A transport the provider builds and owns a client for. */
-	readonly transport?: WireTransport;
+	readonly transport?: WireTransport2;
 	/** Options for the owned client; ignored when `client` is given. */
-	readonly options?: BridgeClientOptions;
+	readonly options?: BridgeClientOptions2;
 	readonly children?: ReactNode;
 }
 /**
@@ -126,23 +36,21 @@ interface BridgeProviderProps {
 */
 declare function BridgeProvider(props: BridgeProviderProps): ReactElement;
 /** The client of the nearest {@link BridgeProvider}. */
-declare function useBridgeClient(): BridgeClient;
+declare function useBridgeClient(): BridgeClient2;
+/**
+* The `QgisSdk` of the nearest {@link BridgeProvider}.
+*
+* The type parameters name the generated `Operations` and `Streams`; they are
+* the caller's claim, the same way the provider's `qgis` prop was the page's.
+*/
+declare function useQgisSdk<
+	O = OperationMap2,
+	S = StreamMap2
+>(): QgisSdk2<O, S>;
 /**
 * Build a generated operation map once per client: `useOperations(createOperations)`.
 */
-declare function useOperations<T>(create: (client: BridgeClient) => T): T;
-/** Where one invocation stands. */
-type OperationState<R> = {
-	readonly status: "idle";
-} | {
-	readonly status: "pending";
-} | {
-	readonly status: "ok";
-	readonly value: R;
-} | {
-	readonly status: "error";
-	readonly error: Error;
-};
+declare function useOperations<T>(create: (client: BridgeClient2) => T): T;
 /** Controls beyond running: abort what is in flight, or forget the outcome. */
 interface OperationControls {
 	/** Abort the in-flight call locally; the host may still run it. */
@@ -150,13 +58,8 @@ interface OperationControls {
 	/** Back to `idle`, aborting anything in flight. */
 	reset(): void;
 }
-/** An operation member of a generated map: input, optional signal, promise. */
-type Operation<
-	I,
-	R
-> = (input: I, options?: {
-	readonly signal?: AbortSignal;
-}) => Promise<R>;
+/** Read any store from a component; the snapshot is the render's value. */
+declare function useStore<T>(store: Store2<T>): T;
 /**
 * Run a generated operation from a component.
 *
@@ -168,39 +71,7 @@ type Operation<
 declare function useOperation<
 	I,
 	R
->(operation: Operation<I, R>): readonly [OperationState<R>, (input: I) => Promise<R | undefined>, OperationControls];
-/** How a stream ended, as the generated module reports it. */
-interface StreamTerminalLike {
-	readonly kind: string;
-	readonly message?: string;
-	readonly dropped?: number;
-}
-/** The handle a generated stream member resolves with. */
-interface StreamHandleLike {
-	readonly id: string;
-	readonly closed: boolean;
-	close(): void;
-}
-/** Handlers for a stream, as a generated module types them. */
-interface StreamHandlersLike<E> {
-	readonly onEvent?: (event: E) => void;
-	readonly onTerminal?: (terminal: StreamTerminalLike) => void;
-}
-/** A stream member of a generated map. */
-type Stream<
-	I,
-	E
-> = (input: I, handlers: StreamHandlersLike<E>, options?: {
-	readonly signal?: AbortSignal;
-}) => Promise<StreamHandleLike>;
-/** Where one subscription stands. */
-interface StreamState<E> {
-	/** `idle` with a null input, `failed` when the host refused to open it. */
-	readonly status: "idle" | "opening" | "open" | "ended" | "failed";
-	readonly lastEvent: E | null;
-	readonly terminal: StreamTerminalLike | null;
-	readonly error: Error | null;
-}
+>(operation: Operation2<I, R>): readonly [OperationState2<R>, (input: I) => Promise<R | undefined>, OperationControls];
 /**
 * Hold a generated stream open while a component is mounted.
 *
@@ -213,5 +84,34 @@ interface StreamState<E> {
 declare function useStream<
 	I,
 	E
->(open: Stream<I, E>, input: I | null, handlers?: StreamHandlersLike<E>): StreamState<E>;
-export { BridgeProvider, BridgeProviderProps, Operation, OperationControls, OperationState, QgisSdkBridgeReactError, Stream, StreamHandleLike, StreamHandlersLike, StreamState, StreamTerminalLike, useBridgeClient, useOperation, useOperations, useStream };
+>(open: Stream2<I, E>, input: I | null, handlers?: StreamHandlersLike2<E>): StreamState2<E>;
+/**
+* The form of one declared action: `qgis.<id>` with its fields, values,
+* issues and submission. The store is built once per `qgis` and `id` - the
+* options are read on the first render only, like `useState`'s initial value
+* - and unmounting aborts a submission in flight.
+*/
+declare function useForm<
+	O,
+	K extends keyof O & string
+>(qgis: QgisSdkCore2<O, unknown>, id: K, options?: FormOptions2): readonly [FormState2<ResultOf<O, K>>, FormStore2<RequestOf<O, K> & object, ResultOf<O, K>>];
+/**
+* Read a host query store: `useHostQuery(layersQuery(qgis))` for a layer
+* picker. `refresh` runs once on mount when `auto` is not `false`.
+*/
+declare function useHostQuery<T>(store: HostQueryStore2<T>, options?: {
+	readonly auto?: boolean;
+}): readonly [HostQueryState2<T>, HostQueryStore2<T>];
+type RequestOf<
+	O,
+	K extends keyof O
+> = O[K] extends {
+	readonly request: infer Req;
+} ? Req : never;
+type ResultOf<
+	O,
+	K extends keyof O
+> = O[K] extends {
+	readonly result: infer Res;
+} ? Res : never;
+export { BridgeProvider, BridgeProviderProps, Operation2 as Operation, OperationControls, OperationState2 as OperationState, QgisSdkBridgeReactError, Stream2 as Stream, StreamHandleLike2 as StreamHandleLike, StreamHandlersLike2 as StreamHandlersLike, StreamState2 as StreamState, StreamTerminalLike2 as StreamTerminalLike, useBridgeClient, useForm, useHostQuery, useOperation, useOperations, useQgisSdk, useStore, useStream };

package/dist/react.js

@@ -1,22 +1,24 @@
 import {
-  QgisSdkError2,
-  isPlainRecord2
-} from "./shared/chunk-0fknax6w.js";
-import {
-  QgisSdkBridgeAbortedError2,
   BridgeClient2
-} from "./shared/chunk-a7bjgeve.js";
+} from "./shared/chunk-8gawbn19.js";
+import {
+  OperationStore2,
+  StreamStore2,
+  FormStore2
+} from "./shared/chunk-t1vpt5yq.js";
+import {
+  QgisSdkError2
+} from "./shared/chunk-2hwva3a3.js";
 
 // src/react.ts
 import {
   createContext,
   createElement,
-  useCallback,
   useContext,
   useEffect,
   useMemo,
-  useRef,
-  useState
+  useState,
+  useSyncExternalStore
 } from "react";
 class QgisSdkBridgeReactError extends QgisSdkError2 {
   constructor(message) {
@@ -25,9 +27,10 @@ class QgisSdkBridgeReactError extends QgisSdkError2 {
 }
 var ClientContext = createContext(null);
 function BridgeProvider(props) {
-  const { client, transport, options, children } = props;
-  if (client === undefined === (transport === undefined)) {
-    throw new QgisSdkBridgeReactError("BridgeProvider needs exactly one of client or transport");
+  const { qgis, client, transport, options, children } = props;
+  const given = [qgis, client, transport].filter((source) => source !== undefined).length;
+  if (given !== 1) {
+    throw new QgisSdkBridgeReactError("BridgeProvider needs exactly one of qgis, client or transport");
   }
   const timeoutMs = options?.timeoutMs;
   const [owned, setOwned] = useState(null);
@@ -42,155 +45,83 @@ function BridgeProvider(props) {
       setOwned((current) => current === live ? null : current);
     };
   }, [transport, timeoutMs]);
-  const value = client ?? owned;
+  const value = useMemo(() => {
+    if (qgis !== undefined) {
+      return { client: qgis.client, qgis };
+    }
+    const live = client ?? owned;
+    return live === null ? null : { client: live, qgis: null };
+  }, [qgis, client, owned]);
   return createElement(ClientContext.Provider, { value }, value === null ? null : children);
 }
+function useShared(hook) {
+  const shared = useContext(ClientContext);
+  if (shared === null) {
+    throw new QgisSdkBridgeReactError(`${hook} needs a BridgeProvider above it`);
+  }
+  return shared;
+}
 function useBridgeClient() {
-  const client = useContext(ClientContext);
-  if (client === null) {
-    throw new QgisSdkBridgeReactError("useBridgeClient needs a BridgeProvider above it");
+  return useShared("useBridgeClient").client;
+}
+function useQgisSdk() {
+  const shared = useShared("useQgisSdk");
+  if (shared.qgis === null) {
+    throw new QgisSdkBridgeReactError("useQgisSdk needs a BridgeProvider given a qgis instance");
   }
-  return client;
+  return shared.qgis;
 }
 function useOperations(create) {
   const client = useBridgeClient();
   return useMemo(() => create(client), [create, client]);
 }
-var IDLE = Object.freeze({ status: "idle" });
-var PENDING = Object.freeze({ status: "pending" });
+function useStore(store) {
+  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
 function useOperation(operation) {
-  const [state, setState] = useState(IDLE);
-  const generation = useRef(0);
-  const controller = useRef(null);
-  const mounted = useRef(true);
-  const abort = useCallback(() => {
-    generation.current += 1;
-    controller.current?.abort();
-    controller.current = null;
-  }, []);
+  const store = useMemo(() => new OperationStore2(operation), [operation]);
+  useEffect(() => () => store.abort(), [store]);
+  const state = useStore(store);
+  const controls = useMemo(() => ({ abort: store.abort, reset: store.reset }), [store]);
+  return [state, store.run, controls];
+}
+function useStream(open, input, handlers = {}) {
+  const store = useMemo(() => new StreamStore2(open), [open]);
+  store.setHandlers(handlers);
   useEffect(() => {
-    mounted.current = true;
-    return () => {
-      mounted.current = false;
-      abort();
-    };
-  }, [abort]);
-  const run = useCallback(async (input) => {
-    abort();
-    const mine = generation.current;
-    const signal = new AbortController;
-    controller.current = signal;
-    setState(PENDING);
-    try {
-      const value = await operation(input, { signal: signal.signal });
-      if (generation.current !== mine || !mounted.current) {
-        return;
-      }
-      setState({ status: "ok", value });
-      return value;
-    } catch (error) {
-      if (generation.current !== mine || !mounted.current) {
-        return;
-      }
-      if (error instanceof QgisSdkBridgeAbortedError2) {
-        return;
-      }
-      setState({
-        status: "error",
-        error: error instanceof Error ? error : new Error(String(error))
-      });
-      return;
-    } finally {
-      if (controller.current === signal) {
-        controller.current = null;
-      }
-    }
-  }, [operation, abort]);
-  const reset = useCallback(() => {
-    abort();
-    setState(IDLE);
-  }, [abort]);
-  const controls = useMemo(() => ({ abort, reset }), [abort, reset]);
-  return [state, run, controls];
+    store.setInput(input);
+  });
+  useEffect(() => () => store.close(), [store]);
+  return useStore(store);
 }
-var IDLE_STREAM = Object.freeze({
-  status: "idle",
-  lastEvent: null,
-  terminal: null,
-  error: null
-});
-function stableKey(value) {
-  return JSON.stringify(value, (_key, item) => isPlainRecord2(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item);
+function useForm(qgis, id, options) {
+  const [first] = useState(() => options ?? {});
+  const store = useMemo(() => new FormStore2(qgis, id, first), [qgis, id, first]);
+  useEffect(() => () => store.abort(), [store]);
+  return [useStore(store), store];
 }
-function useStream(open, input, handlers = {}) {
-  const [state, setState] = useState(IDLE_STREAM);
-  const latest = useRef(handlers);
-  latest.current = handlers;
-  const key = input === null ? null : stableKey(input);
-  const inputRef = useRef(input);
-  inputRef.current = input;
+function useHostQuery(store, options = {}) {
+  const auto = options.auto !== false;
   useEffect(() => {
-    if (key === null) {
-      setState(IDLE_STREAM);
-      return;
+    if (auto) {
+      store.refresh();
     }
-    const current = inputRef.current;
-    let cancelled = false;
-    let handle = null;
-    setState({
-      status: "opening",
-      lastEvent: null,
-      terminal: null,
-      error: null
-    });
-    open(current, {
-      onEvent: (event) => {
-        if (cancelled) {
-          return;
-        }
-        latest.current.onEvent?.(event);
-        setState((previous) => ({ ...previous, lastEvent: event }));
-      },
-      onTerminal: (terminal) => {
-        if (cancelled) {
-          return;
-        }
-        latest.current.onTerminal?.(terminal);
-        setState((previous) => ({ ...previous, status: "ended", terminal }));
-      }
-    }).then((opened) => {
-      if (cancelled) {
-        opened.close();
-        return;
-      }
-      handle = opened;
-      setState((previous) => previous.status === "ended" ? previous : { ...previous, status: "open" });
-    }, (error) => {
-      if (cancelled) {
-        return;
-      }
-      setState({
-        status: "failed",
-        lastEvent: null,
-        terminal: null,
-        error: error instanceof Error ? error : new Error(String(error))
-      });
-    });
-    return () => {
-      cancelled = true;
-      handle?.close();
-    };
-  }, [open, key]);
-  return state;
+    return () => store.abort();
+  }, [store, auto]);
+  return [useStore(store), store];
 }
 export {
   BridgeProvider,
   QgisSdkBridgeReactError,
   useBridgeClient,
+  useForm,
+  useHostQuery,
   useOperation,
   useOperations,
+  useQgisSdk,
+  useStore,
   useStream
 };
 
-//# debugId=B9173116D0A8AD4364756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/react.ts"],
  "sourcesContent": [
    "/**\n * Thin React bindings over the bridge client (TASK-18, decision-18).\n *\n * This entry point is optional and is the only one that imports React. It adds\n * no second client: a component reaches the same `BridgeClient` a vanilla page\n * would build, through a provider that either owns one (and closes it on\n * unmount) or is handed one (and leaves it alone). The hooks take the\n * functions a generated module already exports - `operations.sites.summary`,\n * `operations.sites.watch` - so the typed contract is the generated one, not a\n * React copy of it.\n *\n * What the hooks add is lifetime: a call aborted when its component unmounts,\n * a stale reply ignored, a stream closed on unmount or when its input changes,\n * and a simulated StrictMode remount that leaves exactly one of each.\n */\n\nimport {\n\tcreateContext,\n\tcreateElement,\n\ttype ReactElement,\n\ttype ReactNode,\n\tuseCallback,\n\tuseContext,\n\tuseEffect,\n\tuseMemo,\n\tuseRef,\n\tuseState,\n} from \"react\";\nimport {\n\tBridgeClient,\n\ttype BridgeClientOptions,\n\tQgisSdkBridgeAbortedError,\n\ttype WireTransport,\n} from \"./bridge\";\nimport { isPlainRecord, QgisSdkError } from \"./index\";\n\n/** A hook or provider was used outside the shape it needs. */\nexport class QgisSdkBridgeReactError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"react_binding\");\n\t}\n}\n\nconst ClientContext = createContext<BridgeClient | null>(null);\n\n/** Props for {@link BridgeProvider}: exactly one of `client` or `transport`. */\nexport interface BridgeProviderProps {\n\t/** A client the caller owns; the provider never closes it. */\n\treadonly client?: BridgeClient;\n\t/** A transport the provider builds and owns a client for. */\n\treadonly transport?: WireTransport;\n\t/** Options for the owned client; ignored when `client` is given. */\n\treadonly options?: BridgeClientOptions;\n\treadonly children?: ReactNode;\n}\n\n/**\n * Share one client with a subtree.\n *\n * An owned client is created in an effect, never during render, because\n * StrictMode renders twice and a client made in render would leave a second\n * listener on the transport. Until that effect has run the subtree is not\n * rendered, which is one tick. StrictMode's simulated unmount closes the\n * owned client and the effect that follows makes a new one, so the subtree\n * never holds a dead client. The transport must be stable across renders; to\n * swap it, change the provider's `key`.\n */\nexport function BridgeProvider(props: BridgeProviderProps): ReactElement {\n\tconst { client, transport, options, children } = props;\n\tif ((client === undefined) === (transport === undefined)) {\n\t\tthrow new QgisSdkBridgeReactError(\n\t\t\t\"BridgeProvider needs exactly one of client or transport\",\n\t\t);\n\t}\n\tconst timeoutMs = options?.timeoutMs;\n\tconst [owned, setOwned] = useState<BridgeClient | null>(null);\n\tuseEffect(() => {\n\t\tif (transport === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst live = new BridgeClient(\n\t\t\ttransport,\n\t\t\ttimeoutMs === undefined ? {} : { timeoutMs },\n\t\t);\n\t\tsetOwned(live);\n\t\treturn () => {\n\t\t\tlive.close();\n\t\t\tsetOwned((current) => (current === live ? null : current));\n\t\t};\n\t}, [transport, timeoutMs]);\n\tconst value = client ?? owned;\n\treturn createElement(\n\t\tClientContext.Provider,\n\t\t{ value },\n\t\tvalue === null ? null : children,\n\t);\n}\n\n/** The client of the nearest {@link BridgeProvider}. */\nexport function useBridgeClient(): BridgeClient {\n\tconst client = useContext(ClientContext);\n\tif (client === null) {\n\t\tthrow new QgisSdkBridgeReactError(\n\t\t\t\"useBridgeClient needs a BridgeProvider above it\",\n\t\t);\n\t}\n\treturn client;\n}\n\n/**\n * Build a generated operation map once per client: `useOperations(createOperations)`.\n */\nexport function useOperations<T>(create: (client: BridgeClient) => T): T {\n\tconst client = useBridgeClient();\n\treturn useMemo(() => create(client), [create, client]);\n}\n\n/** Where one invocation stands. */\nexport type OperationState<R> =\n\t| { readonly status: \"idle\" }\n\t| { readonly status: \"pending\" }\n\t| { readonly status: \"ok\"; readonly value: R }\n\t| { readonly status: \"error\"; readonly error: Error };\n\n/** Controls beyond running: abort what is in flight, or forget the outcome. */\nexport interface OperationControls {\n\t/** Abort the in-flight call locally; the host may still run it. */\n\tabort(): void;\n\t/** Back to `idle`, aborting anything in flight. */\n\treset(): void;\n}\n\n/** An operation member of a generated map: input, optional signal, promise. */\nexport type Operation<I, R> = (\n\tinput: I,\n\toptions?: { readonly signal?: AbortSignal },\n) => Promise<R>;\n\nconst IDLE: OperationState<never> = Object.freeze({ status: \"idle\" });\nconst PENDING: OperationState<never> = Object.freeze({ status: \"pending\" });\n\n/**\n * Run a generated operation from a component.\n *\n * `run` resolves with the value, or with `undefined` when the call failed, was\n * aborted or was superseded by a later run - the state carries the error, so\n * the promise never rejects into an event handler. Only the latest run can\n * change the state; unmounting aborts whatever is in flight.\n */\nexport function useOperation<I, R>(\n\toperation: Operation<I, R>,\n): readonly [\n\tOperationState<R>,\n\t(input: I) => Promise<R | undefined>,\n\tOperationControls,\n] {\n\tconst [state, setState] = useState<OperationState<R>>(IDLE);\n\tconst generation = useRef(0);\n\tconst controller = useRef<AbortController | null>(null);\n\tconst mounted = useRef(true);\n\n\tconst abort = useCallback((): void => {\n\t\tgeneration.current += 1;\n\t\tcontroller.current?.abort();\n\t\tcontroller.current = null;\n\t}, []);\n\n\tuseEffect(() => {\n\t\tmounted.current = true;\n\t\treturn () => {\n\t\t\tmounted.current = false;\n\t\t\tabort();\n\t\t};\n\t}, [abort]);\n\n\tconst run = useCallback(\n\t\tasync (input: I): Promise<R | undefined> => {\n\t\t\tabort();\n\t\t\tconst mine = generation.current;\n\t\t\tconst signal = new AbortController();\n\t\t\tcontroller.current = signal;\n\t\t\tsetState(PENDING);\n\t\t\ttry {\n\t\t\t\tconst value = await operation(input, { signal: signal.signal });\n\t\t\t\tif (generation.current !== mine || !mounted.current) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\tsetState({ status: \"ok\", value });\n\t\t\t\treturn value;\n\t\t\t} catch (error) {\n\t\t\t\tif (generation.current !== mine || !mounted.current) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\tif (error instanceof QgisSdkBridgeAbortedError) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\tsetState({\n\t\t\t\t\tstatus: \"error\",\n\t\t\t\t\terror: error instanceof Error ? error : new Error(String(error)),\n\t\t\t\t});\n\t\t\t\treturn undefined;\n\t\t\t} finally {\n\t\t\t\tif (controller.current === signal) {\n\t\t\t\t\tcontroller.current = null;\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t[operation, abort],\n\t);\n\n\tconst reset = useCallback((): void => {\n\t\tabort();\n\t\tsetState(IDLE);\n\t}, [abort]);\n\n\tconst controls = useMemo(() => ({ abort, reset }), [abort, reset]);\n\treturn [state, run, controls];\n}\n\n/** How a stream ended, as the generated module reports it. */\nexport interface StreamTerminalLike {\n\treadonly kind: string;\n\treadonly message?: string;\n\treadonly dropped?: number;\n}\n\n/** The handle a generated stream member resolves with. */\nexport interface StreamHandleLike {\n\treadonly id: string;\n\treadonly closed: boolean;\n\tclose(): void;\n}\n\n/** Handlers for a stream, as a generated module types them. */\nexport interface StreamHandlersLike<E> {\n\treadonly onEvent?: (event: E) => void;\n\treadonly onTerminal?: (terminal: StreamTerminalLike) => void;\n}\n\n/** A stream member of a generated map. */\nexport type Stream<I, E> = (\n\tinput: I,\n\thandlers: StreamHandlersLike<E>,\n\toptions?: { readonly signal?: AbortSignal },\n) => Promise<StreamHandleLike>;\n\n/** Where one subscription stands. */\nexport interface StreamState<E> {\n\t/** `idle` with a null input, `failed` when the host refused to open it. */\n\treadonly status: \"idle\" | \"opening\" | \"open\" | \"ended\" | \"failed\";\n\treadonly lastEvent: E | null;\n\treadonly terminal: StreamTerminalLike | null;\n\treadonly error: Error | null;\n}\n\nconst IDLE_STREAM: StreamState<never> = Object.freeze({\n\tstatus: \"idle\",\n\tlastEvent: null,\n\tterminal: null,\n\terror: null,\n});\n\nfunction stableKey(value: unknown): string {\n\treturn JSON.stringify(value, (_key, item: unknown) =>\n\t\tisPlainRecord(item)\n\t\t\t? Object.fromEntries(\n\t\t\t\t\tObject.entries(item).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),\n\t\t\t\t)\n\t\t\t: item,\n\t);\n}\n\n/**\n * Hold a generated stream open while a component is mounted.\n *\n * The subscription follows `open` and the *content* of `input`: a new object\n * with the same fields does not reopen it, a different one closes the old\n * stream and opens a new one, and `null` closes it. Handlers are read fresh\n * on every frame, so a new closure does not reopen anything either. Unmount\n * closes the stream, even if the host has not yet acknowledged it.\n */\nexport function useStream<I, E>(\n\topen: Stream<I, E>,\n\tinput: I | null,\n\thandlers: StreamHandlersLike<E> = {},\n): StreamState<E> {\n\tconst [state, setState] = useState<StreamState<E>>(IDLE_STREAM);\n\tconst latest = useRef(handlers);\n\tlatest.current = handlers;\n\tconst key = input === null ? null : stableKey(input);\n\t// `input` is deliberately read through `key`: two objects with the same\n\t// fields are the same subscription.\n\tconst inputRef = useRef(input);\n\tinputRef.current = input;\n\n\tuseEffect(() => {\n\t\tif (key === null) {\n\t\t\tsetState(IDLE_STREAM);\n\t\t\treturn undefined;\n\t\t}\n\t\tconst current = inputRef.current as I;\n\t\tlet cancelled = false;\n\t\tlet handle: StreamHandleLike | null = null;\n\t\tsetState({\n\t\t\tstatus: \"opening\",\n\t\t\tlastEvent: null,\n\t\t\tterminal: null,\n\t\t\terror: null,\n\t\t});\n\t\topen(current, {\n\t\t\tonEvent: (event) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tlatest.current.onEvent?.(event);\n\t\t\t\tsetState((previous) => ({ ...previous, lastEvent: event }));\n\t\t\t},\n\t\t\tonTerminal: (terminal) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tlatest.current.onTerminal?.(terminal);\n\t\t\t\tsetState((previous) => ({ ...previous, status: \"ended\", terminal }));\n\t\t\t},\n\t\t}).then(\n\t\t\t(opened) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\topened.close();\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\thandle = opened;\n\t\t\t\tsetState((previous) =>\n\t\t\t\t\tprevious.status === \"ended\"\n\t\t\t\t\t\t? previous\n\t\t\t\t\t\t: { ...previous, status: \"open\" },\n\t\t\t\t);\n\t\t\t},\n\t\t\t(error: unknown) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tsetState({\n\t\t\t\t\tstatus: \"failed\",\n\t\t\t\t\tlastEvent: null,\n\t\t\t\t\tterminal: null,\n\t\t\t\t\terror: error instanceof Error ? error : new Error(String(error)),\n\t\t\t\t});\n\t\t\t},\n\t\t);\n\t\treturn () => {\n\t\t\tcancelled = true;\n\t\t\thandle?.close();\n\t\t};\n\t}, [open, key]);\n\n\treturn state;\n}\n"
  ],
  "mappings": "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",
  "debugId": "B9173116D0A8AD4364756E2164756E21",
  "names": []
}
+//# debugId=AF402B9327384C7B64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/react.ts"],
  "sourcesContent": [
    "/**\n * Thin React bindings over the store core (decision-18, decision-47).\n *\n * This entry point is optional and is the only one that imports React. It adds\n * no second client: a component reaches the same `QgisSdk` or `BridgeClient` a\n * vanilla page would build, through a provider that is handed a `QgisSdk`\n * (and leaves it alone), is handed a client (same), or owns a client built on\n * a transport (and closes it on unmount). The hooks take the methods a\n * `QgisSdk` already has - `qgis.sites.summary`, `qgis.sites.watch` - so\n * the typed contract is the generated one, not a React copy of it.\n *\n * The behaviour lives in `./stores`: `useOperation` is an `OperationStore`\n * read through `useSyncExternalStore`, `useStream` a `StreamStore`, `useForm`\n * a `FormStore` and `useHostQuery` a `HostQueryStore`. What the hooks add is\n * lifetime: a call aborted when its component unmounts, a stream closed on\n * unmount or when its input changes, and a simulated StrictMode remount that\n * leaves exactly one of each.\n */\n\nimport {\n\tcreateContext,\n\tcreateElement,\n\ttype ReactElement,\n\ttype ReactNode,\n\tuseContext,\n\tuseEffect,\n\tuseMemo,\n\tuseState,\n\tuseSyncExternalStore,\n} from \"react\";\nimport {\n\tBridgeClient,\n\ttype BridgeClientOptions,\n\ttype WireTransport,\n} from \"./bridge\";\nimport { QgisSdkError } from \"./errors\";\nimport type { QgisSdk, QgisSdkCore } from \"./qgis-sdk\";\nimport type { OperationMap, StreamMap } from \"./schema\";\nimport {\n\ttype FormOptions,\n\ttype FormState,\n\tFormStore,\n\ttype HostQueryState,\n\ttype HostQueryStore,\n\ttype Operation,\n\ttype OperationState,\n\tOperationStore,\n\ttype Store,\n\ttype Stream,\n\ttype StreamHandlersLike,\n\ttype StreamState,\n\tStreamStore,\n} from \"./stores\";\n\nexport type {\n\tOperation,\n\tOperationState,\n\tStream,\n\tStreamHandleLike,\n\tStreamHandlersLike,\n\tStreamState,\n\tStreamTerminalLike,\n} from \"./stores\";\n\n/** A hook or provider was used outside the shape it needs. */\nexport class QgisSdkBridgeReactError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"react_binding\");\n\t}\n}\n\ninterface Shared {\n\treadonly client: BridgeClient;\n\treadonly qgis: QgisSdkCore<unknown, unknown> | null;\n}\n\nconst ClientContext = createContext<Shared | null>(null);\n\n/** Props for {@link BridgeProvider}: exactly one of `qgis`, `client` or `transport`. */\nexport interface BridgeProviderProps {\n\t/**\n\t * A `QgisSdk` the page built, whatever its schema; the provider shares it\n\t * and never closes it. `useQgisSdk` hands it back under the page's types.\n\t */\n\treadonly qgis?: QgisSdkCore<unknown, unknown>;\n\t/** A client the caller owns; the provider never closes it. */\n\treadonly client?: BridgeClient;\n\t/** A transport the provider builds and owns a client for. */\n\treadonly transport?: WireTransport;\n\t/** Options for the owned client; ignored when `client` is given. */\n\treadonly options?: BridgeClientOptions;\n\treadonly children?: ReactNode;\n}\n\n/**\n * Share one client with a subtree.\n *\n * An owned client is created in an effect, never during render, because\n * StrictMode renders twice and a client made in render would leave a second\n * listener on the transport. Until that effect has run the subtree is not\n * rendered, which is one tick. StrictMode's simulated unmount closes the\n * owned client and the effect that follows makes a new one, so the subtree\n * never holds a dead client. The transport must be stable across renders; to\n * swap it, change the provider's `key`.\n */\nexport function BridgeProvider(props: BridgeProviderProps): ReactElement {\n\tconst { qgis, client, transport, options, children } = props;\n\tconst given = [qgis, client, transport].filter(\n\t\t(source) => source !== undefined,\n\t).length;\n\tif (given !== 1) {\n\t\tthrow new QgisSdkBridgeReactError(\n\t\t\t\"BridgeProvider needs exactly one of qgis, client or transport\",\n\t\t);\n\t}\n\tconst timeoutMs = options?.timeoutMs;\n\tconst [owned, setOwned] = useState<BridgeClient | null>(null);\n\tuseEffect(() => {\n\t\tif (transport === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst live = new BridgeClient(\n\t\t\ttransport,\n\t\t\ttimeoutMs === undefined ? {} : { timeoutMs },\n\t\t);\n\t\tsetOwned(live);\n\t\treturn () => {\n\t\t\tlive.close();\n\t\t\tsetOwned((current) => (current === live ? null : current));\n\t\t};\n\t}, [transport, timeoutMs]);\n\tconst value = useMemo((): Shared | null => {\n\t\tif (qgis !== undefined) {\n\t\t\treturn { client: qgis.client, qgis };\n\t\t}\n\t\tconst live = client ?? owned;\n\t\treturn live === null ? null : { client: live, qgis: null };\n\t}, [qgis, client, owned]);\n\treturn createElement(\n\t\tClientContext.Provider,\n\t\t{ value },\n\t\tvalue === null ? null : children,\n\t);\n}\n\nfunction useShared(hook: string): Shared {\n\tconst shared = useContext(ClientContext);\n\tif (shared === null) {\n\t\tthrow new QgisSdkBridgeReactError(\n\t\t\t`${hook} needs a BridgeProvider above it`,\n\t\t);\n\t}\n\treturn shared;\n}\n\n/** The client of the nearest {@link BridgeProvider}. */\nexport function useBridgeClient(): BridgeClient {\n\treturn useShared(\"useBridgeClient\").client;\n}\n\n/**\n * The `QgisSdk` of the nearest {@link BridgeProvider}.\n *\n * The type parameters name the generated `Operations` and `Streams`; they are\n * the caller's claim, the same way the provider's `qgis` prop was the page's.\n */\nexport function useQgisSdk<O = OperationMap, S = StreamMap>(): QgisSdk<O, S> {\n\tconst shared = useShared(\"useQgisSdk\");\n\tif (shared.qgis === null) {\n\t\tthrow new QgisSdkBridgeReactError(\n\t\t\t\"useQgisSdk needs a BridgeProvider given a qgis instance\",\n\t\t);\n\t}\n\treturn shared.qgis as unknown as QgisSdk<O, S>;\n}\n\n/**\n * Build a generated operation map once per client: `useOperations(createOperations)`.\n */\nexport function useOperations<T>(create: (client: BridgeClient) => T): T {\n\tconst client = useBridgeClient();\n\treturn useMemo(() => create(client), [create, client]);\n}\n\n/** Controls beyond running: abort what is in flight, or forget the outcome. */\nexport interface OperationControls {\n\t/** Abort the in-flight call locally; the host may still run it. */\n\tabort(): void;\n\t/** Back to `idle`, aborting anything in flight. */\n\treset(): void;\n}\n\n/** Read any store from a component; the snapshot is the render's value. */\nexport function useStore<T>(store: Store<T>): T {\n\treturn useSyncExternalStore(\n\t\tstore.subscribe,\n\t\tstore.getSnapshot,\n\t\tstore.getSnapshot,\n\t);\n}\n\n/**\n * Run a generated operation from a component.\n *\n * `run` resolves with the value, or with `undefined` when the call failed, was\n * aborted or was superseded by a later run - the state carries the error, so\n * the promise never rejects into an event handler. Only the latest run can\n * change the state; unmounting aborts whatever is in flight.\n */\nexport function useOperation<I, R>(\n\toperation: Operation<I, R>,\n): readonly [\n\tOperationState<R>,\n\t(input: I) => Promise<R | undefined>,\n\tOperationControls,\n] {\n\tconst store = useMemo(() => new OperationStore(operation), [operation]);\n\tuseEffect(() => () => store.abort(), [store]);\n\tconst state = useStore(store);\n\tconst controls = useMemo(\n\t\t() => ({ abort: store.abort, reset: store.reset }),\n\t\t[store],\n\t);\n\treturn [state, store.run, controls];\n}\n\n/**\n * Hold a generated stream open while a component is mounted.\n *\n * The subscription follows `open` and the *content* of `input`: a new object\n * with the same fields does not reopen it, a different one closes the old\n * stream and opens a new one, and `null` closes it. Handlers are read fresh\n * on every frame, so a new closure does not reopen anything either. Unmount\n * closes the stream, even if the host has not yet acknowledged it.\n */\nexport function useStream<I, E>(\n\topen: Stream<I, E>,\n\tinput: I | null,\n\thandlers: StreamHandlersLike<E> = {},\n): StreamState<E> {\n\tconst store = useMemo(() => new StreamStore(open), [open]);\n\tstore.setHandlers(handlers);\n\t// The store keys the input by content, so an effect per render is cheap\n\t// and a new object with the same fields reopens nothing.\n\tuseEffect(() => {\n\t\tstore.setInput(input);\n\t});\n\tuseEffect(() => () => store.close(), [store]);\n\treturn useStore(store);\n}\n\n/**\n * The form of one declared action: `qgis.<id>` with its fields, values,\n * issues and submission. The store is built once per `qgis` and `id` - the\n * options are read on the first render only, like `useState`'s initial value\n * - and unmounting aborts a submission in flight.\n */\nexport function useForm<O, K extends keyof O & string>(\n\tqgis: QgisSdkCore<O, unknown>,\n\tid: K,\n\toptions?: FormOptions,\n): readonly [\n\tFormState<ResultOf<O, K>>,\n\tFormStore<RequestOf<O, K> & object, ResultOf<O, K>>,\n] {\n\tconst [first] = useState(() => options ?? {});\n\tconst store = useMemo(\n\t\t() =>\n\t\t\tnew FormStore<RequestOf<O, K> & object, ResultOf<O, K>>(\n\t\t\t\tqgis as QgisSdkCore<unknown, unknown>,\n\t\t\t\tid,\n\t\t\t\tfirst,\n\t\t\t),\n\t\t[qgis, id, first],\n\t);\n\t// Abort, not dispose: StrictMode's simulated unmount keeps the store.\n\tuseEffect(() => () => store.abort(), [store]);\n\treturn [useStore(store), store];\n}\n\n/**\n * Read a host query store: `useHostQuery(layersQuery(qgis))` for a layer\n * picker. `refresh` runs once on mount when `auto` is not `false`.\n */\nexport function useHostQuery<T>(\n\tstore: HostQueryStore<T>,\n\toptions: { readonly auto?: boolean } = {},\n): readonly [HostQueryState<T>, HostQueryStore<T>] {\n\tconst auto = options.auto !== false;\n\tuseEffect(() => {\n\t\tif (auto) {\n\t\t\tvoid store.refresh();\n\t\t}\n\t\treturn () => store.abort();\n\t}, [store, auto]);\n\treturn [useStore(store), store];\n}\n\ntype RequestOf<O, K extends keyof O> = O[K] extends {\n\treadonly request: infer Req;\n}\n\t? Req\n\t: never;\ntype ResultOf<O, K extends keyof O> = O[K] extends {\n\treadonly result: infer Res;\n}\n\t? Res\n\t: never;\n"
  ],
  "mappings": "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",
  "debugId": "AF402B9327384C7B64756E2164756E21",
  "names": []
}

package/dist/shared/chunk-2hwva3a3.js

@@ -0,0 +1,14 @@
+// src/errors.ts
+class QgisSdkError2 extends Error {
+  code;
+  constructor(message, code = "sdk_error") {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+  }
+}
+
+export { QgisSdkError2 };
+
+//# debugId=87B5084359C9044664756E2164756E21
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsic3JjL2Vycm9ycy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICAgICIvKipcbiAqIFRoZSBvbmUgZXJyb3Igcm9vdCBvZiBgQGFyY2hvbnQ1NjEvcWdpcy1zZGtgLlxuICpcbiAqIEV2ZXJ5IGVycm9yIHRoaXMgcGFja2FnZSByYWlzZXMgLSB0cmFuc3BvcnQsIGhvc3QgY29udHJhY3QsIFJlYWN0IGJpbmRpbmcsXG4gKiB0ZXN0IGhhcm5lc3MgLSBleHRlbmRzIGBRZ2lzU2RrRXJyb3JgLCBzbyBhIHBhZ2UgY2FuIGNhdGNoIHRoZSBmYW1pbHkgaW4gb25lXG4gKiBgaW5zdGFuY2VvZmAgYW5kIHN3aXRjaCBvbiB0aGUgc3RhYmxlIHdpcmUgYGNvZGVgIHJhdGhlciB0aGFuIG9uIGNsYXNzIG5hbWVzXG4gKiBvciBtZXNzYWdlIHRleHQuIFRoZSBjbGFzcyBsaXZlcyBpbiBpdHMgb3duIG1vZHVsZSBzbyB0aGUgZW50cnkgcG9pbnRzIGNhblxuICogc2hhcmUgaXQgd2l0aG91dCBpbXBvcnRpbmcgZWFjaCBvdGhlci5cbiAqL1xuXG4vKipcbiAqIEJhc2UgY2xhc3MgZm9yIGV4cGVjdGVkIFNESyBlcnJvcnMgYWNyb3NzIHRoZSBicmlkZ2UgYm91bmRhcnkuXG4gKi9cbmV4cG9ydCBjbGFzcyBRZ2lzU2RrRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG5cdHB1YmxpYyByZWFkb25seSBjb2RlOiBzdHJpbmc7XG5cblx0cHVibGljIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZywgY29kZTogc3RyaW5nID0gXCJzZGtfZXJyb3JcIikge1xuXHRcdHN1cGVyKG1lc3NhZ2UpO1xuXHRcdHRoaXMubmFtZSA9IG5ldy50YXJnZXQubmFtZTtcblx0XHR0aGlzLmNvZGUgPSBjb2RlO1xuXHR9XG59XG4iCiAgXSwKICAibWFwcGluZ3MiOiAiO0FBYU8sTUFBTSxzQkFBcUIsTUFBTTtBQUFBLEVBQ3ZCO0FBQUEsRUFFVCxXQUFXLENBQUMsU0FBaUIsT0FBZSxhQUFhO0FBQUEsSUFDL0QsTUFBTSxPQUFPO0FBQUEsSUFDYixLQUFLLE9BQU8sV0FBVztBQUFBLElBQ3ZCLEtBQUssT0FBTztBQUFBO0FBRWQ7IiwKICAiZGVidWdJZCI6ICI4N0I1MDg0MzU5QzkwNDQ2NjQ3NTZFMjE2NDc1NkUyMSIsCiAgIm5hbWVzIjogW10KfQ==