@archont561/qgis-sdk 0.0.0 → 0.4.0

package/dist/react.d.ts

@@ -0,0 +1,137 @@
+import { WireTransport2, BridgeClientOptions2, BridgeClient2 } from "./shared/chunk-wtv4vt4q.js";
+import "./shared/chunk-khemhx86.js";
+import { OperationMap2, StreamMap2 } from "./shared/chunk-jjx14tgd.js";
+import { QgisSdkCore2, QgisSdk2 } from "./shared/chunk-tmca1ynt.js";
+import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
+import { ReactElement, ReactNode } from "react";
+/** A hook or provider was used outside the shape it needs. */
+declare class QgisSdkBridgeReactError extends QgisSdkError2 {
+	constructor(message: string);
+}
+/** 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?: BridgeClient2;
+	/** A transport the provider builds and owns a client for. */
+	readonly transport?: WireTransport2;
+	/** Options for the owned client; ignored when `client` is given. */
+	readonly options?: BridgeClientOptions2;
+	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(): 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: BridgeClient2) => 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, useQgisSdk, useStream };

package/dist/react.js

@@ -0,0 +1,214 @@
+import {
+  isPlainRecord,
+  QgisSdkBridgeAbortedError2,
+  BridgeClient2
+} from "./shared/chunk-8gawbn19.js";
+import {
+  QgisSdkError2
+} from "./shared/chunk-2hwva3a3.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 { 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);
+  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 = 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() {
+  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 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 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) => isPlainRecord(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,
+  useQgisSdk,
+  useStream
+};
+
+//# debugId=0FA8371D474034FF64756E2164756E21
+//# 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 `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 * 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 { QgisSdkError } from \"./errors\";\nimport { isPlainRecord } from \"./internal\";\nimport type { QgisSdk, QgisSdkCore } from \"./qgis-sdk\";\nimport type { OperationMap, StreamMap } from \"./schema\";\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/** 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": "0FA8371D474034FF64756E2164756E21",
  "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==