@archont561/qgis-sdk-bridge 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,163 +1,31 @@
-// src/index.ts
-var MAX_SAFE_INTEGER = 9007199254740991;
-var MIN_SAFE_INTEGER = -9007199254740991;
-var PLUGIN_DESCRIPTION_SCHEMA_VERSION = 1;
-function isSafeJsonInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value);
-}
-
-class QgisSdkError extends Error {
-  code;
-  constructor(message, code = "sdk_error") {
-    super(message);
-    this.name = new.target.name;
-    this.code = code;
-  }
-}
-
-class QgisSdkScopeClosedError extends QgisSdkError {
-  constructor() {
-    super("This resource scope has been disposed", "scope_closed");
-  }
-}
-
-class QgisSdkUnsupportedCapabilityError extends QgisSdkError {
-  capability;
-  constructor(capability) {
-    super(`Capability ${JSON.stringify(capability)} is unavailable in this runtime`, "unsupported_capability");
-    this.capability = capability;
-  }
-}
-
-class QgisSdkDeclarationError extends QgisSdkError {
-  constructor(message) {
-    super(message, "invalid_declaration");
-  }
-}
-
-class QgisSdkValidationIssue {
-  path;
-  code;
-  constructor(path, code) {
-    this.path = Object.freeze([...path]);
-    this.code = code;
-  }
-  toJSON() {
-    return {
-      path: [...this.path],
-      code: this.code
-    };
-  }
-}
-
-class QgisSdkContractValidationError extends QgisSdkError {
-  direction;
-  issues;
-  constructor(direction, issues) {
-    const prefix = direction === "request" ? "Request" : "Result";
-    super(`${prefix} contract validation failed`, "contract_validation_failed");
-    this.direction = direction;
-    this.issues = Object.freeze([...issues]);
-  }
-  toJSON() {
-    return {
-      code: this.code,
-      direction: this.direction,
-      issues: this.issues.map((issue) => issue.toJSON())
-    };
-  }
-}
-var DECLARATION_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
-var PYTHON_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function isPlainRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validateDeclarationId(value, label) {
-  if (typeof value !== "string" || !DECLARATION_ID_PATTERN.test(value)) {
-    throw new QgisSdkDeclarationError(`Invalid ${label} id: expected [a-zA-Z][a-zA-Z0-9_.-]*`);
-  }
-  return value;
-}
-function validateNonBlankTitle(value, id) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new QgisSdkDeclarationError(`${id}: title must be a nonempty string`);
-  }
-  return value;
-}
-function parseActionDescription(raw) {
-  if (!isPlainRecord(raw)) {
-    throw new QgisSdkDeclarationError("Action description must be an object");
-  }
-  const id = validateDeclarationId(raw.id, "action");
-  const title = validateNonBlankTitle(raw.title, id);
-  if (typeof raw.handler !== "string" || !PYTHON_IDENTIFIER_PATTERN.test(raw.handler)) {
-    throw new QgisSdkDeclarationError(`${id}: handler must be a valid Python identifier`);
-  }
-  if (!isPlainRecord(raw.request)) {
-    throw new QgisSdkDeclarationError(`${id}: request schema must be an object`);
-  }
-  if (!isPlainRecord(raw.result)) {
-    throw new QgisSdkDeclarationError(`${id}: result schema must be an object`);
-  }
-  return Object.freeze({
-    id,
-    title,
-    handler: raw.handler,
-    request: Object.freeze({ ...raw.request }),
-    result: Object.freeze({ ...raw.result })
-  });
-}
-function parsePluginDescription(input) {
-  let parsed = input;
-  if (typeof input === "string") {
-    try {
-      parsed = JSON.parse(input);
-    } catch {
-      throw new QgisSdkDeclarationError("Plugin description is not valid JSON");
-    }
-  }
-  if (!isPlainRecord(parsed)) {
-    throw new QgisSdkDeclarationError("Plugin description must be an object");
-  }
-  if (parsed.schema_version !== PLUGIN_DESCRIPTION_SCHEMA_VERSION) {
-    throw new QgisSdkDeclarationError(`Unsupported plugin description schema_version: ${String(parsed.schema_version)}`);
-  }
-  const id = validateDeclarationId(parsed.id, "plugin");
-  const title = validateNonBlankTitle(parsed.title, id);
-  if (!Array.isArray(parsed.actions)) {
-    throw new QgisSdkDeclarationError(`${id}: actions must be an array`);
-  }
-  const seenIds = new Set;
-  const actions = [];
-  for (const item of parsed.actions) {
-    const action = parseActionDescription(item);
-    if (seenIds.has(action.id)) {
-      throw new QgisSdkDeclarationError(`${id}: duplicate action id ${action.id}`);
-    }
-    seenIds.add(action.id);
-    actions.push(action);
-  }
-  actions.sort((left, right) => left.id < right.id ? -1 : 1);
-  return Object.freeze({
-    schema_version: PLUGIN_DESCRIPTION_SCHEMA_VERSION,
-    id,
-    title,
-    actions: Object.freeze(actions)
-  });
-}
+import {
+  MAX_SAFE_INTEGER2,
+  MIN_SAFE_INTEGER2,
+  PLUGIN_DESCRIPTION_SCHEMA_VERSION2,
+  isSafeJsonInteger2,
+  QgisSdkError2,
+  QgisSdkScopeClosedError2,
+  QgisSdkUnsupportedCapabilityError2,
+  QgisSdkDeclarationError2,
+  QgisSdkValidationIssue2,
+  QgisSdkContractValidationError2,
+  isPlainRecord2,
+  parsePluginDescription2
+} from "./shared/chunk-0fknax6w.js";
 export {
-  MAX_SAFE_INTEGER,
-  MIN_SAFE_INTEGER,
-  PLUGIN_DESCRIPTION_SCHEMA_VERSION,
-  QgisSdkContractValidationError,
-  QgisSdkDeclarationError,
-  QgisSdkError,
-  QgisSdkScopeClosedError,
-  QgisSdkUnsupportedCapabilityError,
-  QgisSdkValidationIssue,
-  isSafeJsonInteger,
-  parsePluginDescription
+  MAX_SAFE_INTEGER2 as MAX_SAFE_INTEGER,
+  MIN_SAFE_INTEGER2 as MIN_SAFE_INTEGER,
+  PLUGIN_DESCRIPTION_SCHEMA_VERSION2 as PLUGIN_DESCRIPTION_SCHEMA_VERSION,
+  QgisSdkContractValidationError2 as QgisSdkContractValidationError,
+  QgisSdkDeclarationError2 as QgisSdkDeclarationError,
+  QgisSdkError2 as QgisSdkError,
+  QgisSdkScopeClosedError2 as QgisSdkScopeClosedError,
+  QgisSdkUnsupportedCapabilityError2 as QgisSdkUnsupportedCapabilityError,
+  QgisSdkValidationIssue2 as QgisSdkValidationIssue,
+  isPlainRecord2 as isPlainRecord,
+  isSafeJsonInteger2 as isSafeJsonInteger,
+  parsePluginDescription2 as parsePluginDescription
 };
 
-//# debugId=3494C4156313BA2364756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/index.ts"],
  "sourcesContent": [
    "/**\n * Public 0.1.0 contract, wire-limit, and error primitives for the QGIS SDK bridge.\n *\n * Mirrors the QGIS-free `qgis_sdk.models` and `qgis_sdk.declarations`\n * (`schema_version = 1`) contracts without importing browser or Qt globals.\n */\n\nexport const MAX_SAFE_INTEGER: number = 9_007_199_254_740_991;\nexport const MIN_SAFE_INTEGER: number = -9_007_199_254_740_991;\nexport const PLUGIN_DESCRIPTION_SCHEMA_VERSION: 1 = 1;\n\nexport type ValidationDirection = \"request\" | \"result\";\n\nexport interface SerializedValidationIssue {\n\treadonly path: (string | number)[];\n\treadonly code: string;\n}\n\nexport interface SerializedContractValidationError {\n\treadonly code: string;\n\treadonly direction: ValidationDirection;\n\treadonly issues: SerializedValidationIssue[];\n}\n\nexport interface ActionDescription {\n\treadonly id: string;\n\treadonly title: string;\n\treadonly handler: string;\n\treadonly request: Readonly<Record<string, unknown>>;\n\treadonly result: Readonly<Record<string, unknown>>;\n}\n\nexport interface PluginDescription {\n\treadonly schema_version: 1;\n\treadonly id: string;\n\treadonly title: string;\n\treadonly actions: readonly ActionDescription[];\n}\n\n/**\n * Return whether `value` is a finite integer within the JavaScript-safe wire range.\n */\nexport function isSafeJsonInteger(value: unknown): value is number {\n\treturn typeof value === \"number\" && Number.isSafeInteger(value);\n}\n\n/**\n * Base class for expected SDK errors across the bridge boundary.\n */\nexport class QgisSdkError extends Error {\n\tpublic readonly code: string;\n\n\tpublic constructor(message: string, code: string = \"sdk_error\") {\n\t\tsuper(message);\n\t\tthis.name = new.target.name;\n\t\tthis.code = code;\n\t}\n}\n\n/**\n * An operation attempted to use an already disposed owner scope.\n */\nexport class QgisSdkScopeClosedError extends QgisSdkError {\n\tpublic constructor() {\n\t\tsuper(\"This resource scope has been disposed\", \"scope_closed\");\n\t}\n}\n\n/**\n * The selected runtime does not offer an explicitly requested capability.\n */\nexport class QgisSdkUnsupportedCapabilityError extends QgisSdkError {\n\tpublic readonly capability: string;\n\n\tpublic constructor(capability: string) {\n\t\tsuper(\n\t\t\t`Capability ${JSON.stringify(capability)} is unavailable in this runtime`,\n\t\t\t\"unsupported_capability\",\n\t\t);\n\t\tthis.capability = capability;\n\t}\n}\n\n/**\n * A declaration cannot be represented or parsed in the versioned contract.\n */\nexport class QgisSdkDeclarationError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"invalid_declaration\");\n\t}\n}\n\n/**\n * Safe, structured location and category for a rejected contract value.\n */\nexport class QgisSdkValidationIssue {\n\tpublic readonly path: readonly (string | number)[];\n\tpublic readonly code: string;\n\n\tpublic constructor(path: readonly (string | number)[], code: string) {\n\t\tthis.path = Object.freeze([...path]);\n\t\tthis.code = code;\n\t}\n\n\tpublic toJSON(): SerializedValidationIssue {\n\t\treturn {\n\t\t\tpath: [...this.path],\n\t\t\tcode: this.code,\n\t\t};\n\t}\n}\n\n/**\n * A request or result did not satisfy its declared wire contract.\n */\nexport class QgisSdkContractValidationError extends QgisSdkError {\n\tpublic readonly direction: ValidationDirection;\n\tpublic readonly issues: readonly QgisSdkValidationIssue[];\n\n\tpublic constructor(\n\t\tdirection: ValidationDirection,\n\t\tissues: readonly QgisSdkValidationIssue[],\n\t) {\n\t\tconst prefix = direction === \"request\" ? \"Request\" : \"Result\";\n\t\tsuper(`${prefix} contract validation failed`, \"contract_validation_failed\");\n\t\tthis.direction = direction;\n\t\tthis.issues = Object.freeze([...issues]);\n\t}\n\n\tpublic toJSON(): SerializedContractValidationError {\n\t\treturn {\n\t\t\tcode: this.code,\n\t\t\tdirection: this.direction,\n\t\t\tissues: this.issues.map((issue) => issue.toJSON()),\n\t\t};\n\t}\n}\n\nconst DECLARATION_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;\nconst PYTHON_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n\treturn typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction validateDeclarationId(value: unknown, label: string): string {\n\tif (typeof value !== \"string\" || !DECLARATION_ID_PATTERN.test(value)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`Invalid ${label} id: expected [a-zA-Z][a-zA-Z0-9_.-]*`,\n\t\t);\n\t}\n\treturn value;\n}\n\nfunction validateNonBlankTitle(value: unknown, id: string): string {\n\tif (typeof value !== \"string\" || value.trim().length === 0) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: title must be a nonempty string`);\n\t}\n\treturn value;\n}\n\nfunction parseActionDescription(raw: unknown): ActionDescription {\n\tif (!isPlainRecord(raw)) {\n\t\tthrow new QgisSdkDeclarationError(\"Action description must be an object\");\n\t}\n\tconst id = validateDeclarationId(raw.id, \"action\");\n\tconst title = validateNonBlankTitle(raw.title, id);\n\tif (\n\t\ttypeof raw.handler !== \"string\" ||\n\t\t!PYTHON_IDENTIFIER_PATTERN.test(raw.handler)\n\t) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: handler must be a valid Python identifier`,\n\t\t);\n\t}\n\tif (!isPlainRecord(raw.request)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: request schema must be an object`,\n\t\t);\n\t}\n\tif (!isPlainRecord(raw.result)) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: result schema must be an object`);\n\t}\n\treturn Object.freeze({\n\t\tid,\n\t\ttitle,\n\t\thandler: raw.handler,\n\t\trequest: Object.freeze({ ...raw.request }),\n\t\tresult: Object.freeze({ ...raw.result }),\n\t});\n}\n\n/**\n * Parse and validate a version 1 `PluginDescription` emitted by `describe_plugin`.\n */\nexport function parsePluginDescription(\n\tinput: string | Readonly<Record<string, unknown>>,\n): PluginDescription {\n\tlet parsed: unknown = input;\n\tif (typeof input === \"string\") {\n\t\ttry {\n\t\t\tparsed = JSON.parse(input);\n\t\t} catch {\n\t\t\tthrow new QgisSdkDeclarationError(\"Plugin description is not valid JSON\");\n\t\t}\n\t}\n\tif (!isPlainRecord(parsed)) {\n\t\tthrow new QgisSdkDeclarationError(\"Plugin description must be an object\");\n\t}\n\tif (parsed.schema_version !== PLUGIN_DESCRIPTION_SCHEMA_VERSION) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`Unsupported plugin description schema_version: ${String(parsed.schema_version)}`,\n\t\t);\n\t}\n\tconst id = validateDeclarationId(parsed.id, \"plugin\");\n\tconst title = validateNonBlankTitle(parsed.title, id);\n\tif (!Array.isArray(parsed.actions)) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: actions must be an array`);\n\t}\n\tconst seenIds = new Set<string>();\n\tconst actions: ActionDescription[] = [];\n\tfor (const item of parsed.actions) {\n\t\tconst action = parseActionDescription(item);\n\t\tif (seenIds.has(action.id)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${id}: duplicate action id ${action.id}`,\n\t\t\t);\n\t\t}\n\t\tseenIds.add(action.id);\n\t\tactions.push(action);\n\t}\n\tactions.sort((left, right) => (left.id < right.id ? -1 : 1));\n\treturn Object.freeze({\n\t\tschema_version: PLUGIN_DESCRIPTION_SCHEMA_VERSION,\n\t\tid,\n\t\ttitle,\n\t\tactions: Object.freeze(actions),\n\t});\n}\n"
  ],
  "mappings": "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",
  "debugId": "3494C4156313BA2364756E2164756E21",
  "names": []
}
+//# debugId=B8E64E2D8764D48064756E2164756E21
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICBdLAogICJtYXBwaW5ncyI6ICIiLAogICJkZWJ1Z0lkIjogIkI4RTY0RTJEODc2NEQ0ODA2NDc1NkUyMTY0NzU2RTIxIiwKICAibmFtZXMiOiBbXQp9

package/dist/react.d.ts

@@ -0,0 +1,217 @@
+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 {
+	constructor(message: string);
+}
+/** Props for {@link BridgeProvider}: exactly one of `client` or `transport`. */
+interface BridgeProviderProps {
+	/** A client the caller owns; the provider never closes it. */
+	readonly client?: BridgeClient;
+	/** A transport the provider builds and owns a client for. */
+	readonly transport?: WireTransport;
+	/** Options for the owned client; ignored when `client` is given. */
+	readonly options?: BridgeClientOptions;
+	readonly children?: ReactNode;
+}
+/**
+* Share one client with a subtree.
+*
+* An owned client is created in an effect, never during render, because
+* StrictMode renders twice and a client made in render would leave a second
+* listener on the transport. Until that effect has run the subtree is not
+* rendered, which is one tick. StrictMode's simulated unmount closes the
+* owned client and the effect that follows makes a new one, so the subtree
+* never holds a dead client. The transport must be stable across renders; to
+* swap it, change the provider's `key`.
+*/
+declare function BridgeProvider(props: BridgeProviderProps): ReactElement;
+/** The client of the nearest {@link BridgeProvider}. */
+declare function useBridgeClient(): BridgeClient;
+/**
+* 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;
+};
+/** 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. */
+	abort(): void;
+	/** 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>;
+/**
+* Run a generated operation from a component.
+*
+* `run` resolves with the value, or with `undefined` when the call failed, was
+* aborted or was superseded by a later run - the state carries the error, so
+* the promise never rejects into an event handler. Only the latest run can
+* change the state; unmounting aborts whatever is in flight.
+*/
+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;
+}
+/**
+* Hold a generated stream open while a component is mounted.
+*
+* The subscription follows `open` and the *content* of `input`: a new object
+* with the same fields does not reopen it, a different one closes the old
+* stream and opens a new one, and `null` closes it. Handlers are read fresh
+* on every frame, so a new closure does not reopen anything either. Unmount
+* closes the stream, even if the host has not yet acknowledged it.
+*/
+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 };

package/dist/react.js

@@ -0,0 +1,196 @@
+import {
+  QgisSdkError2,
+  isPlainRecord2
+} from "./shared/chunk-0fknax6w.js";
+import {
+  QgisSdkBridgeAbortedError2,
+  BridgeClient2
+} from "./shared/chunk-a7bjgeve.js";
+
+// src/react.ts
+import {
+  createContext,
+  createElement,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+class QgisSdkBridgeReactError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "react_binding");
+  }
+}
+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 timeoutMs = options?.timeoutMs;
+  const [owned, setOwned] = useState(null);
+  useEffect(() => {
+    if (transport === undefined) {
+      return;
+    }
+    const live = new BridgeClient2(transport, timeoutMs === undefined ? {} : { timeoutMs });
+    setOwned(live);
+    return () => {
+      live.close();
+      setOwned((current) => current === live ? null : current);
+    };
+  }, [transport, timeoutMs]);
+  const value = client ?? owned;
+  return createElement(ClientContext.Provider, { value }, value === null ? null : children);
+}
+function useBridgeClient() {
+  const client = useContext(ClientContext);
+  if (client === null) {
+    throw new QgisSdkBridgeReactError("useBridgeClient needs a BridgeProvider above it");
+  }
+  return client;
+}
+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 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;
+  }, []);
+  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];
+}
+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 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;
+  useEffect(() => {
+    if (key === null) {
+      setState(IDLE_STREAM);
+      return;
+    }
+    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;
+}
+export {
+  BridgeProvider,
+  QgisSdkBridgeReactError,
+  useBridgeClient,
+  useOperation,
+  useOperations,
+  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": []
}