@archont561/qgis-sdk 0.0.0 → 0.4.0

package/dist/shared/chunk-khemhx86.d.ts

@@ -0,0 +1,158 @@
+import { QgisSdkError2 } from "./chunk-pdj2fxjb.js";
+declare const HOST_ID2 = "qgis.host";
+declare const HOST_FINGERPRINT2 = "sha256:f96bdf1046434de3c5eae01efb34c8ad2bcd1cf241a3dc42f6c4b613dc7d7d6f";
+declare const HOST_SCHEMA_VERSION2 = 1;
+/** Every declared operation id, so a name can be checked, not guessed. */
+declare const HOST_OPERATIONS2: readonly ["files.export", "layers.get", "layers.list", "layers.open_vector", "network.fetch", "notifications.info", "project.layer_ids", "settings.get", "styles.apply"];
+type HostOperationId2 = (typeof HOST_OPERATIONS2)[number];
+interface HostInvokeOptions2 {
+	readonly signal?: AbortSignal;
+}
+/** The client this module wraps: anything with a correlated invoke. */
+interface HostClientLike2 {
+	invoke(operation: string, payload?: Readonly<Record<string, unknown>>, options?: HostInvokeOptions2): Promise<unknown>;
+	subscribe(operation: string, payload?: Readonly<Record<string, unknown>>, handlers?: HostStreamHandlers2<{
+		readonly kind: "data" | "progress" | "state";
+		readonly payload: unknown;
+	}>, options?: HostInvokeOptions2): Promise<HostStreamHandle2>;
+}
+/** How a stream ended; `dropped` is only present for a gap. */
+interface HostStreamTerminal2 {
+	readonly kind: "complete" | "error" | "cancelled" | "gap" | "disposed";
+	readonly message?: string;
+	readonly dropped?: number;
+}
+/** What a stream reports: typed events, then exactly one end. */
+interface HostStreamHandlers2<E> {
+	readonly onEvent?: (event: E) => void;
+	readonly onTerminal?: (terminal: HostStreamTerminal2) => void;
+}
+/** A live stream, as the caller holds it. */
+interface HostStreamHandle2 {
+	readonly id: string;
+	readonly closed: boolean;
+	close(): void;
+}
+/** An argument or a response that does not match its declared schema. */
+declare class QgisSdkHostContractError2 extends QgisSdkError2 {
+	readonly operation: string;
+	constructor(operation: string, message: string);
+}
+interface ExportRequest2 {
+	readonly content: string;
+	readonly file: FileRef2;
+}
+interface ExportResult2 {
+	readonly bytes_written: number;
+	readonly name: string;
+}
+interface FetchRequest2 {
+	readonly auth_config?: string;
+	readonly body?: string;
+	readonly headers?: readonly HttpHeader2[];
+	readonly method?: "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+	readonly timeout_seconds?: number;
+	readonly url: string;
+}
+interface FileRef2 {
+	readonly id: string;
+	readonly kind: "file";
+	readonly name?: string;
+	readonly operations?: readonly ("read" | "write")[];
+}
+interface HttpHeader2 {
+	readonly name: string;
+	readonly value: string;
+}
+interface IdPage2 {
+	readonly items: readonly string[];
+	readonly next_cursor?: string;
+	readonly truncated: boolean;
+}
+interface LayerPage2 {
+	readonly items: readonly VectorLayerInfo2[];
+	readonly next_cursor?: string;
+	readonly truncated: boolean;
+}
+interface LayerRequest2 {
+	readonly layer_id: string;
+}
+interface NetworkFetchData2 {
+	readonly base64: string | null;
+	readonly headers: readonly HttpHeader2[];
+	readonly reason: string;
+	readonly status_code: number;
+	readonly text: string | null;
+	readonly url: string;
+}
+interface NotificationsInfoRequest2 {
+	readonly message: string;
+}
+interface OpenVectorRequest2 {
+	readonly file: FileRef2;
+}
+interface PageRequest2 {
+	readonly cursor?: string;
+	readonly limit?: number;
+}
+interface SettingsGetRequest2 {
+	readonly default?: string | null;
+	readonly key: string;
+}
+interface StylesApplyRequest2 {
+	readonly layer_id: string;
+	readonly style: string;
+}
+interface VectorLayerInfo2 {
+	readonly crs: string | null;
+	readonly field_names: readonly string[];
+	readonly geometry_type: "point" | "line" | "polygon" | "none";
+	readonly id: string;
+	readonly name: string;
+}
+declare function ExportRequest2(value: unknown, strict?: boolean): value is ExportRequest2;
+declare function ExportResult2(value: unknown, strict?: boolean): value is ExportResult2;
+declare function FetchRequest2(value: unknown, strict?: boolean): value is FetchRequest2;
+declare function IdPage2(value: unknown, strict?: boolean): value is IdPage2;
+declare function LayerPage2(value: unknown, strict?: boolean): value is LayerPage2;
+declare function LayerRequest2(value: unknown, strict?: boolean): value is LayerRequest2;
+declare function NetworkFetchData2(value: unknown, strict?: boolean): value is NetworkFetchData2;
+declare function NotificationsInfoRequest2(value: unknown, strict?: boolean): value is NotificationsInfoRequest2;
+declare function OpenVectorRequest2(value: unknown, strict?: boolean): value is OpenVectorRequest2;
+declare function PageRequest2(value: unknown, strict?: boolean): value is PageRequest2;
+declare function SettingsGetRequest2(value: unknown, strict?: boolean): value is SettingsGetRequest2;
+declare function StylesApplyRequest2(value: unknown, strict?: boolean): value is StylesApplyRequest2;
+/** One event of `network.fetch`, narrowed by its kind. */
+type NetworkFetchEvent2 = {
+	readonly kind: "data";
+	readonly payload: NetworkFetchData2;
+};
+declare function NetworkFetchEvent2(value: unknown, strict?: boolean): value is NetworkFetchEvent2;
+/** Every operation this surface declares, as callable methods. */
+interface HostOperations2 {
+	readonly files: {
+		readonly export: (input: ExportRequest2, options?: HostInvokeOptions2) => Promise<ExportResult2>;
+	};
+	readonly layers: {
+		readonly get: (input: LayerRequest2, options?: HostInvokeOptions2) => Promise<VectorLayerInfo2>;
+		readonly list: (input?: PageRequest2, options?: HostInvokeOptions2) => Promise<LayerPage2>;
+		readonly open_vector: (input: OpenVectorRequest2, options?: HostInvokeOptions2) => Promise<VectorLayerInfo2>;
+	};
+	readonly network: {
+		readonly fetch: (input: FetchRequest2, handlers: HostStreamHandlers2<NetworkFetchEvent2>, options?: HostInvokeOptions2) => Promise<HostStreamHandle2>;
+	};
+	readonly notifications: {
+		readonly info: (input: NotificationsInfoRequest2, options?: HostInvokeOptions2) => Promise<null>;
+	};
+	readonly project: {
+		readonly layer_ids: (input?: PageRequest2, options?: HostInvokeOptions2) => Promise<IdPage2>;
+	};
+	readonly settings: {
+		readonly get: (input: SettingsGetRequest2, options?: HostInvokeOptions2) => Promise<string | null>;
+	};
+	readonly styles: {
+		readonly apply: (input: StylesApplyRequest2, options?: HostInvokeOptions2) => Promise<null>;
+	};
+}
+declare function createHost2(client: HostClientLike2): HostOperations2;
+export { HOST_ID2, HOST_FINGERPRINT2, HOST_SCHEMA_VERSION2, HOST_OPERATIONS2, HostOperationId2, HostInvokeOptions2, HostClientLike2, HostStreamTerminal2, HostStreamHandlers2, HostStreamHandle2, QgisSdkHostContractError2, ExportRequest2, ExportResult2, FetchRequest2, FileRef2, HttpHeader2, IdPage2, LayerPage2, LayerRequest2, NetworkFetchData2, NotificationsInfoRequest2, OpenVectorRequest2, PageRequest2, SettingsGetRequest2, StylesApplyRequest2, VectorLayerInfo2, NetworkFetchEvent2, HostOperations2, createHost2 };

package/dist/shared/chunk-pdj2fxjb.d.ts

@@ -0,0 +1,17 @@
+/**
+* The one error root of `@archont561/qgis-sdk`.
+*
+* Every error this package raises - transport, host contract, React binding,
+* test harness - extends `QgisSdkError`, so a page can catch the family in one
+* `instanceof` and switch on the stable wire `code` rather than on class names
+* or message text. The class lives in its own module so the entry points can
+* share it without importing each other.
+*/
+/**
+* Base class for expected SDK errors across the bridge boundary.
+*/
+declare class QgisSdkError2 extends Error {
+	readonly code: string;
+	constructor(message: string, code?: string);
+}
+export { QgisSdkError2 };

package/dist/shared/chunk-tmca1ynt.d.ts

@@ -0,0 +1,87 @@
+import { BridgeStreamTerminal2, WireTransport2, InvokeOptions2, BridgeSubscription2, BridgeClient2 } from "./chunk-wtv4vt4q.js";
+import { HostOperationId2, HostOperations2 } from "./chunk-khemhx86.js";
+import { OperationShape2, StreamShape2, OperationMap2, StreamMap2, BridgeSchema2 } from "./chunk-jjx14tgd.js";
+/** Options for {@link QgisSdk.fromBridgeSchema}. */
+interface QgisSdkOptions2 {
+	/** A transport to speak through; defaults to the page's QWebChannel. */
+	readonly transport?: WireTransport2;
+	/** A client the caller owns; `close()` leaves it open. Excludes `transport`. */
+	readonly client?: BridgeClient2;
+	/** Per-call timeout for an owned client. */
+	readonly timeoutMs?: number;
+	/** The channel object's name when the default transport is used. */
+	readonly channelObject?: string;
+}
+/** Handlers for a typed stream: events as declared, then exactly one end. */
+interface StreamHandlers2<E> {
+	readonly onEvent?: (event: E) => void;
+	readonly onTerminal?: (terminal: BridgeStreamTerminal2) => void;
+}
+/** A live stream, as the caller holds it. */
+type StreamHandle2 = BridgeSubscription2;
+/** The method one declared action becomes; an empty request may be omitted. */
+type OperationMethod2<Op extends OperationShape2> = {} extends Op["request"] ? (request?: Op["request"], options?: InvokeOptions2) => Promise<Op["result"]> : (request: Op["request"], options?: InvokeOptions2) => Promise<Op["result"]>;
+/** The method one declared stream becomes. */
+type StreamMethod2<St extends StreamShape2> = (request: St["request"], handlers: StreamHandlers2<St["event"]>, options?: InvokeOptions2) => Promise<StreamHandle2>;
+/** What the handshake told this page about the host (decision-27). */
+interface QgisSdkHost2 extends HostOperations2 {
+	/**
+	* The host operation ids the handshake advertised for this view; empty
+	* until {@link QgisSdkCore.ready} has resolved.
+	*/
+	readonly granted: readonly HostOperationId2[];
+}
+/** The members every `QgisSdk` has, whatever its schema declares. */
+interface QgisSdkCore2<
+	O = OperationMap2,
+	S = StreamMap2
+> {
+	/** The schema this instance was built from. */
+	readonly schema: BridgeSchema2<O, S>;
+	/** The client under the methods, for what a method does not cover. */
+	readonly client: BridgeClient2;
+	/** The curated host surface, and what this view was granted of it. */
+	readonly host: QgisSdkHost2;
+	/** Resolves once the handshake answered; rejects when the host refused it. */
+	readonly ready: Promise<void>;
+	/** Close an owned client; a client the caller passed in is left alone. */
+	close(): void;
+}
+/** The first segment of a dotted id, or the whole id when it has none. */
+type Head<K extends string> = K extends `${infer H}.${string}` ? H : K;
+/** The members of `M` under one head, keyed by the rest of their ids. */
+type Under<
+	M,
+	H extends string
+> = { [K in keyof M & string as K extends `${H}.${infer Rest}` ? Rest : never] : M[K] };
+/**
+* The declared actions as a tree: a plain id is a method, a dotted id nests
+* one object per segment. An id that is both a leaf and a prefix of another
+* is refused at run time, so the type need not say what it would mean.
+*/
+type OperationTree2<O> = { readonly [H in Head<keyof O & string>] : H extends keyof O ? O[H] extends OperationShape2 ? OperationMethod2<O[H]> : never : OperationTree2<Under<O, H>> };
+/** The declared streams as the same tree, with a stream method at each leaf. */
+type StreamTree2<S> = { readonly [H in Head<keyof S & string>] : H extends keyof S ? S[H] extends StreamShape2 ? StreamMethod2<S[H]> : never : StreamTree2<Under<S, H>> };
+/**
+* A page's handle on QGIS: the core, plus one method per declared operation
+* nested under the segments of its id.
+*/
+type QgisSdk2<
+	O = OperationMap2,
+	S = StreamMap2
+> = QgisSdkCore2<O, S> & OperationTree2<O> & StreamTree2<S>;
+/** Names {@link QgisSdkCore} keeps; a declared id may not start with one. */
+declare const QGIS_SDK_MEMBERS2: readonly string[];
+/**
+* The entry point: `QgisSdk.fromBridgeSchema(schema)`.
+*
+* A namespace rather than a constant so the value and the instance type share
+* one name through every declaration bundler.
+*/
+declare namespace QgisSdk2 {
+	function fromBridgeSchema<
+		O extends Record<keyof O, OperationShape2>,
+		S extends Record<keyof S, StreamShape2>
+	>(schema: BridgeSchema2<O, S>, options?: QgisSdkOptions2): QgisSdk2<O, S>;
+}
+export { QgisSdkOptions2, StreamHandlers2, StreamHandle2, OperationMethod2, StreamMethod2, QgisSdkHost2, QgisSdkCore2, OperationTree2, StreamTree2, QGIS_SDK_MEMBERS2, QgisSdk2 };