@archont561/qgis-sdk 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,31 +1,418 @@
+import {
+  isPlainRecord,
+  BRIDGE_PROTOCOL_VERSION2,
+  MAX_CALL_ID_LENGTH2,
+  QgisSdkBridgeProtocolError2,
+  QgisSdkBridgeTimeoutError2,
+  QgisSdkBridgeAbortedError2,
+  QgisSdkBridgeClosedError2,
+  QgisSdkBridgeSequenceError2,
+  QgisSdkBridgeStreamEndedError2,
+  QgisSdkBridgeRemoteError2,
+  parseInvokeReply2,
+  parseStreamFrame2,
+  BridgeClient2
+} from "./shared/chunk-8gawbn19.js";
 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";
+  parsePluginDescription2,
+  QgisSdkContractError2,
+  validateAgainstSchema2,
+  QgisSdkStoreError2,
+  OperationStore2,
+  stableKey2,
+  StreamStore2,
+  labelFor2,
+  schemaFields2,
+  FormStore2,
+  formStore2,
+  HostQueryStore2,
+  layersQuery2,
+  layerFieldsQuery2
+} from "./shared/chunk-t1vpt5yq.js";
+import {
+  HOST_OPERATIONS2,
+  createHost2
+} from "./shared/chunk-stre69mw.js";
+import {
+  QgisSdkError2
+} from "./shared/chunk-2hwva3a3.js";
+// src/processing.ts
+async function runAlgorithm(qgis, id, params, options) {
+  const raw = await qgis.host.algorithms.run({ algorithm_id: id, params }, options);
+  return {
+    algorithm: raw.algorithm,
+    outputs: outputsByName(raw.outputs),
+    raw
+  };
+}
+function outputsByName(outputs) {
+  const result = {};
+  for (const output of outputs) {
+    if (output.kind === "vector")
+      result[output.name] = output.layer;
+    else if (output.kind === "file")
+      result[output.name] = output.file;
+    else
+      result[output.name] = output.value;
+  }
+  return result;
+}
+// src/webchannel.ts
+class QgisSdkWebChannelError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "no_web_channel");
+  }
+}
+function scope() {
+  return globalThis;
+}
+function insideQgis() {
+  const page = scope();
+  return page.qt !== undefined && typeof page.QWebChannel === "function";
+}
+function createWebChannelTransport(objectName = "bridge") {
+  const page = scope();
+  const qt = page.qt;
+  const QWebChannel = page.QWebChannel;
+  if (qt === undefined || typeof QWebChannel !== "function") {
+    throw new QgisSdkWebChannelError("not inside a QGIS web view: window.qt is missing");
+  }
+  const listeners = new Set;
+  const queue = [];
+  let object = null;
+  let failure = null;
+  let closed = false;
+  const forward = (text) => {
+    if (closed) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return;
+    }
+    for (const listener of [...listeners]) {
+      listener(parsed);
+    }
+  };
+  const ready = new Promise((resolve, reject) => {
+    new QWebChannel(qt.webChannelTransport, (channel) => {
+      const found = channel.objects[objectName];
+      if (found === undefined) {
+        failure = new QgisSdkWebChannelError(`the host registered no ${JSON.stringify(objectName)} channel object`);
+        queue.length = 0;
+        reject(failure);
+        return;
+      }
+      if (closed) {
+        resolve();
+        return;
+      }
+      object = found;
+      found.message.connect(forward);
+      for (const text of queue.splice(0)) {
+        found.receive(text);
+      }
+      resolve();
+    });
+  });
+  return {
+    ready,
+    send(message) {
+      if (closed) {
+        throw new QgisSdkWebChannelError("the web channel transport is closed");
+      }
+      if (failure !== null) {
+        throw failure;
+      }
+      const text = JSON.stringify(message);
+      if (object === null) {
+        queue.push(text);
+        return;
+      }
+      object.receive(text);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      queue.length = 0;
+      listeners.clear();
+      object?.message.disconnect(forward);
+    }
+  };
+}
+
+// src/qgis-sdk.ts
+var QGIS_SDK_MEMBERS = Object.freeze([
+  "client",
+  "host",
+  "schema",
+  "ready",
+  "close"
+]);
+var HOST_IDS = new Set(HOST_OPERATIONS2);
+function parseHandshake(value) {
+  if (!isPlainRecord(value) || !Array.isArray(value.operations)) {
+    throw new QgisSdkBridgeProtocolError2("The handshake reply carries no operations list");
+  }
+  const operations = [];
+  for (const operation of value.operations) {
+    if (isPlainRecord(operation) && typeof operation.id === "string") {
+      operations.push(operation.id);
+    }
+  }
+  return {
+    operations,
+    granted: Object.freeze(operations.filter((id) => HOST_IDS.has(id))),
+    theme: parseTheme(value.theme)
+  };
+}
+function parseTheme(value) {
+  if (!isPlainRecord(value) || !isPlainRecord(value.palette)) {
+    return null;
+  }
+  const palette = {};
+  for (const [role, colour] of Object.entries(value.palette)) {
+    if (typeof colour === "string") {
+      palette[role] = colour;
+    }
+  }
+  return Object.freeze({
+    palette: Object.freeze(palette),
+    dark: value.dark === true
+  });
+}
+function unwrapRequest(operation, request) {
+  if (request === undefined) {
+    return {};
+  }
+  if (!isPlainRecord(request)) {
+    throw new QgisSdkContractError2(operation, "request", [
+      ...validateAgainstSchema2(request, { type: "object" })
+    ]);
+  }
+  return request;
+}
+function checkedRequest(description, request) {
+  const payload = unwrapRequest(description.id, request);
+  const issues = validateAgainstSchema2(payload, description.request);
+  if (issues.length > 0) {
+    throw new QgisSdkContractError2(description.id, "request", issues);
+  }
+  return payload;
+}
+function operationMethod(client, action) {
+  return async (request, options) => {
+    const payload = checkedRequest(action, request);
+    const value = await client.invoke(action.id, payload, options);
+    const issues = validateAgainstSchema2(value, action.result, {
+      allowUnknown: true
+    });
+    if (issues.length > 0) {
+      throw new QgisSdkContractError2(action.id, "result", issues);
+    }
+    return value;
+  };
+}
+function streamMethod(client, stream) {
+  return async (request, handlers, options) => {
+    const payload = checkedRequest(stream, request);
+    let ended = false;
+    let violated = false;
+    let handle = null;
+    const end = (terminal) => {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      handlers.onTerminal?.(terminal);
+    };
+    handle = await client.subscribe(stream.id, payload, {
+      onEvent: (event) => {
+        if (ended) {
+          return;
+        }
+        const declared = stream.events[event.kind];
+        const issues = declared === undefined ? undefined : validateAgainstSchema2(event.payload, declared, {
+          allowUnknown: true,
+          path: ["payload"]
+        });
+        if (issues !== undefined && issues.length === 0) {
+          handlers.onEvent?.(event);
+          return;
+        }
+        const error = new QgisSdkContractError2(stream.id, "event", issues ?? []);
+        end({ kind: "error", message: error.message });
+        if (handle === null) {
+          violated = true;
+        } else {
+          handle.close();
+        }
+      },
+      onTerminal: end
+    }, options);
+    if (violated) {
+      handle.close();
+    }
+    return handle;
+  };
+}
+function buildHost(client, handshake) {
+  const host = createHost2(client);
+  return Object.freeze({
+    ...host,
+    get granted() {
+      return granted(handshake());
+    },
+    get theme() {
+      return handshake()?.theme ?? null;
+    }
+  });
+}
+var NO_GRANTS = Object.freeze([]);
+function granted(handshake) {
+  return handshake === null ? NO_GRANTS : handshake.granted;
+}
+function build(schema, options) {
+  if (options.client !== undefined && options.transport !== undefined) {
+    throw new QgisSdkDeclarationError2("QgisSdk.fromBridgeSchema takes a client or a transport, not both");
+  }
+  const owned = options.client === undefined;
+  const transport = options.transport ?? (options.client === undefined ? createWebChannelTransport(options.channelObject ?? "bridge") : undefined);
+  const client = options.client ?? new BridgeClient2(transport, options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs });
+  let handshake = null;
+  const ready = client.handshake().then((value) => {
+    handshake = parseHandshake(value);
+  });
+  ready.catch(() => {
+    return;
+  });
+  const members = {
+    schema,
+    client,
+    host: buildHost(client, () => handshake),
+    ready,
+    close: () => {
+      if (owned) {
+        client.close();
+      }
+    }
+  };
+  const namespaces = [];
+  for (const action of schema.actions) {
+    place(members, namespaces, action.id, operationMethod(client, action));
+  }
+  for (const stream of schema.streams) {
+    place(members, namespaces, stream.id, streamMethod(client, stream));
+  }
+  for (const namespace of namespaces) {
+    Object.freeze(namespace);
+  }
+  return Object.freeze(members);
+}
+function place(members, namespaces, id, method) {
+  const segments = id.split(".");
+  if (segments.some((segment) => segment === "")) {
+    throw new QgisSdkDeclarationError2(`${id}: an operation id may not have an empty segment`);
+  }
+  const head = segments[0];
+  if (QGIS_SDK_MEMBERS.includes(head)) {
+    throw new QgisSdkDeclarationError2(`${id}: an operation id may not start with a QgisSdk member (${QGIS_SDK_MEMBERS.join(", ")})`);
+  }
+  let node = members;
+  for (const [index, segment] of segments.entries()) {
+    const prefix = segments.slice(0, index + 1).join(".");
+    const existing = node[segment];
+    if (index === segments.length - 1) {
+      if (existing !== undefined) {
+        throw new QgisSdkDeclarationError2(typeof existing === "function" ? `${id}: duplicate operation id` : `${id}: an operation id may not be a prefix of another declared id`);
+      }
+      node[segment] = method;
+      return;
+    }
+    if (existing === undefined) {
+      const namespace = {};
+      namespaces.push(namespace);
+      node[segment] = namespace;
+      node = namespace;
+    } else if (typeof existing === "function") {
+      throw new QgisSdkDeclarationError2(`${id}: ${prefix} is already an operation id; an id may not extend another`);
+    } else {
+      node = existing;
+    }
+  }
+}
+var QgisSdk;
+((QgisSdk) => {
+  function fromBridgeSchema(schema, options = {}) {
+    return build(schema, options);
+  }
+  QgisSdk.fromBridgeSchema = fromBridgeSchema;
+})(QgisSdk ||= {});
+// src/schema.ts
+function defineBridgeSchema(input) {
+  return parsePluginDescription2(input);
+}
 export {
+  BRIDGE_PROTOCOL_VERSION2 as BRIDGE_PROTOCOL_VERSION,
+  BridgeClient2 as BridgeClient,
+  FormStore2 as FormStore,
+  HostQueryStore2 as HostQueryStore,
+  MAX_CALL_ID_LENGTH2 as MAX_CALL_ID_LENGTH,
   MAX_SAFE_INTEGER2 as MAX_SAFE_INTEGER,
   MIN_SAFE_INTEGER2 as MIN_SAFE_INTEGER,
+  OperationStore2 as OperationStore,
   PLUGIN_DESCRIPTION_SCHEMA_VERSION2 as PLUGIN_DESCRIPTION_SCHEMA_VERSION,
+  QGIS_SDK_MEMBERS,
+  QgisSdk,
+  QgisSdkBridgeAbortedError2 as QgisSdkBridgeAbortedError,
+  QgisSdkBridgeClosedError2 as QgisSdkBridgeClosedError,
+  QgisSdkBridgeProtocolError2 as QgisSdkBridgeProtocolError,
+  QgisSdkBridgeRemoteError2 as QgisSdkBridgeRemoteError,
+  QgisSdkBridgeSequenceError2 as QgisSdkBridgeSequenceError,
+  QgisSdkBridgeStreamEndedError2 as QgisSdkBridgeStreamEndedError,
+  QgisSdkBridgeTimeoutError2 as QgisSdkBridgeTimeoutError,
+  QgisSdkContractError2 as QgisSdkContractError,
   QgisSdkContractValidationError2 as QgisSdkContractValidationError,
   QgisSdkDeclarationError2 as QgisSdkDeclarationError,
   QgisSdkError2 as QgisSdkError,
-  QgisSdkScopeClosedError2 as QgisSdkScopeClosedError,
-  QgisSdkUnsupportedCapabilityError2 as QgisSdkUnsupportedCapabilityError,
+  QgisSdkStoreError2 as QgisSdkStoreError,
   QgisSdkValidationIssue2 as QgisSdkValidationIssue,
-  isPlainRecord2 as isPlainRecord,
+  QgisSdkWebChannelError,
+  StreamStore2 as StreamStore,
+  createWebChannelTransport,
+  defineBridgeSchema,
+  formStore2 as formStore,
+  insideQgis,
   isSafeJsonInteger2 as isSafeJsonInteger,
-  parsePluginDescription2 as parsePluginDescription
+  labelFor2 as labelFor,
+  layerFieldsQuery2 as layerFieldsQuery,
+  layersQuery2 as layersQuery,
+  outputsByName,
+  parseInvokeReply2 as parseInvokeReply,
+  parsePluginDescription2 as parsePluginDescription,
+  parseStreamFrame2 as parseStreamFrame,
+  runAlgorithm,
+  schemaFields2 as schemaFields,
+  stableKey2 as stableKey,
+  validateAgainstSchema2 as validateAgainstSchema
 };
 
-//# debugId=B8E64E2D8764D48064756E2164756E21
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICBdLAogICJtYXBwaW5ncyI6ICIiLAogICJkZWJ1Z0lkIjogIkI4RTY0RTJEODc2NEQ0ODA2NDc1NkUyMTY0NzU2RTIxIiwKICAibmFtZXMiOiBbXQp9
+//# debugId=507C47A54A87BD1B64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/processing.ts", "src/webchannel.ts", "src/qgis-sdk.ts", "src/schema.ts"],
  "sourcesContent": [
    "/**\n * Processing from a page (decision-64): the value aliases a generated\n * `processing.schema.ts` annotates with, and `runAlgorithm`, which sends one\n * `algorithms.run` and reshapes the tagged outputs into the result object the\n * generated `<Provider><Algorithm>Result` type spells.\n *\n * The typing lives in the generated module, not here: `qgis-sdk processing\n * generate` emits an `AlgorithmRegistry` for the providers the project asked\n * for and a `runAlgorithm` bound to it. This module is generic over any such\n * registry so the bridge itself ships no catalogue (decision-47: zero runtime\n * data that goes stale with a QGIS release).\n *\n * The host validates the parameters against the algorithm's own description\n * before anything runs; a layer input is an owned layer id, a file input is a\n * ref the host minted for this view, and an omitted destination comes back as\n * an owned layer or a readable ref.\n */\n\nimport type {\n\tFileRef,\n\tHostInvokeOptions,\n\tHostOperations,\n\tRunOutput,\n\tRunResult,\n\tVectorLayerInfo,\n} from \"./generated/host\";\n\nexport type {\n\tAlgorithmInfo,\n\tAlgorithmSummary,\n\tFileRef,\n\tHostInvokeOptions,\n\tOutputInfo,\n\tParameterInfo,\n\tProviderInfo,\n\tRunOutput,\n\tRunResult,\n\tVectorLayerInfo,\n} from \"./generated/host\";\n\n/** A layer input: the id of a layer the host owns, or a ref the view holds. */\nexport type LayerRef = string | FileRef;\n/** Where an output goes: a writable ref, or `null` to let the host allocate one. */\nexport type Destination = FileRef | null;\n/** `\"xmin,xmax,ymin,ymax [crs]\"` as QGIS writes it, or the four numbers. */\nexport type Extent = string | readonly [number, number, number, number];\n/** `\"x,y [crs]\"` or the two numbers. */\nexport type PointValue = string | readonly [number, number];\n/** `[lower, upper]`. */\nexport type RangeValue = readonly [number, number];\n\n/**\n * What a generated `AlgorithmRegistry` is: params and result per algorithm id.\n * Spelled as a mapped constraint over the registry itself so an `interface`\n * (which has no implicit index signature) satisfies it.\n */\nexport type AlgorithmRegistryLike<R> = {\n\treadonly [K in keyof R]: { readonly params: object; readonly result: object };\n};\n\n/** The part of a `QgisSdk` (or anything else) `runAlgorithm` needs. */\nexport interface AlgorithmHost {\n\treadonly host: Pick<HostOperations, \"algorithms\">;\n}\n\n/** One run as the page sees it: the outputs by name, plus the reply as it crossed. */\nexport interface AlgorithmRun<Result extends object> {\n\treadonly algorithm: string;\n\treadonly outputs: Result;\n\treadonly raw: RunResult;\n}\n\n/**\n * Run `id` with `params` through `qgis.host.algorithms.run` and reshape the\n * reply: a `vector` output becomes its `VectorLayerInfo`, a `file` output its\n * `FileRef`, a `value` output the scalar - keyed by output name, which is what\n * the generated `...Result` interfaces declare.\n *\n * Both type parameters are meant to be bound by the generated module's own\n * `runAlgorithm`; calling this one directly needs them spelled out.\n */\nexport async function runAlgorithm<\n\tR extends AlgorithmRegistryLike<R>,\n\tK extends keyof R & string,\n>(\n\tqgis: AlgorithmHost,\n\tid: K,\n\tparams: R[K][\"params\"],\n\toptions?: HostInvokeOptions,\n): Promise<AlgorithmRun<R[K][\"result\"]>> {\n\tconst raw = await qgis.host.algorithms.run(\n\t\t{ algorithm_id: id, params: params as Record<string, unknown> },\n\t\toptions,\n\t);\n\treturn {\n\t\talgorithm: raw.algorithm,\n\t\toutputs: outputsByName(raw.outputs) as R[K][\"result\"],\n\t\traw,\n\t};\n}\n\n/** Unwrap a tagged output list into `{ [name]: layer | ref | value }`. */\nexport function outputsByName(\n\toutputs: readonly RunOutput[],\n): Record<\n\tstring,\n\tVectorLayerInfo | FileRef | string | number | boolean | null | undefined\n> {\n\tconst result: Record<\n\t\tstring,\n\t\tVectorLayerInfo | FileRef | string | number | boolean | null | undefined\n\t> = {};\n\tfor (const output of outputs) {\n\t\tif (output.kind === \"vector\") result[output.name] = output.layer;\n\t\telse if (output.kind === \"file\") result[output.name] = output.file;\n\t\telse result[output.name] = output.value;\n\t}\n\treturn result;\n}\n",
    "/**\n * The default transport: Qt's WebChannel, as a QGIS web view injects it.\n *\n * QGIS registers one object on the channel (the example names it \"bridge\";\n * see `create_channel_object` in the Python runtime). Its `receive` slot takes\n * a JSON envelope and its `message` signal carries every reply and stream\n * frame back. The channel becomes ready on a later turn, so this transport\n * is lazy: a `QgisSdk` built in the first statement of a page can send at\n * once, and what it sent is delivered when the channel reports ready.\n *\n * This is the one module of the root entry point that reads a browser global,\n * and it only does so when called: importing it touches nothing, and a page\n * that is not inside QGIS gets a synchronous, named refusal instead of a hang.\n */\n\nimport type { WireTransport } from \"./bridge\";\nimport { QgisSdkError } from \"./errors\";\n\ninterface ChannelObject {\n\treceive(text: string): void;\n\treadonly message: {\n\t\tconnect(listener: (text: string) => void): void;\n\t\tdisconnect(listener: (text: string) => void): void;\n\t};\n}\n\ninterface Channel {\n\treadonly objects: Readonly<Record<string, ChannelObject | undefined>>;\n}\n\ninterface QtScope {\n\treadonly qt?: { readonly webChannelTransport: unknown };\n\treadonly QWebChannel?: new (\n\t\ttransport: unknown,\n\t\tready: (channel: Channel) => void,\n\t) => unknown;\n}\n\n/** The web view did not provide a usable channel. */\nexport class QgisSdkWebChannelError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"no_web_channel\");\n\t}\n}\n\n/** The transport {@link createWebChannelTransport} returns. */\nexport interface WebChannelTransport extends WireTransport {\n\t/** Resolves once the channel object answered; rejects when it never will. */\n\treadonly ready: Promise<void>;\n\t/** Stop forwarding messages; sends after this throw. */\n\tclose(): void;\n}\n\nfunction scope(): QtScope {\n\treturn globalThis as unknown as QtScope;\n}\n\n/** True inside a QGIS web view, where Qt injected its transport and script. */\nexport function insideQgis(): boolean {\n\tconst page = scope();\n\treturn page.qt !== undefined && typeof page.QWebChannel === \"function\";\n}\n\n/**\n * Connect to the channel object `objectName` and return a transport on it.\n *\n * Throws {@link QgisSdkWebChannelError} synchronously outside a QGIS web view,\n * so a page learns in its first statement that it has no host to talk to.\n * Inside one, messages sent before the channel is ready are queued and\n * delivered in order once it is; `ready` rejects (and queued sends are\n * dropped) when the host registered no object under that name.\n */\nexport function createWebChannelTransport(\n\tobjectName = \"bridge\",\n): WebChannelTransport {\n\tconst page = scope();\n\tconst qt = page.qt;\n\tconst QWebChannel = page.QWebChannel;\n\tif (qt === undefined || typeof QWebChannel !== \"function\") {\n\t\tthrow new QgisSdkWebChannelError(\n\t\t\t\"not inside a QGIS web view: window.qt is missing\",\n\t\t);\n\t}\n\tconst listeners = new Set<(message: unknown) => void>();\n\tconst queue: string[] = [];\n\tlet object: ChannelObject | null = null;\n\tlet failure: QgisSdkWebChannelError | null = null;\n\tlet closed = false;\n\tconst forward = (text: string): void => {\n\t\tif (closed) {\n\t\t\treturn;\n\t\t}\n\t\tlet parsed: unknown;\n\t\ttry {\n\t\t\tparsed = JSON.parse(text);\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tfor (const listener of [...listeners]) {\n\t\t\tlistener(parsed);\n\t\t}\n\t};\n\tconst ready = new Promise<void>((resolve, reject) => {\n\t\tnew QWebChannel(qt.webChannelTransport, (channel) => {\n\t\t\tconst found = channel.objects[objectName];\n\t\t\tif (found === undefined) {\n\t\t\t\tfailure = new QgisSdkWebChannelError(\n\t\t\t\t\t`the host registered no ${JSON.stringify(objectName)} channel object`,\n\t\t\t\t);\n\t\t\t\tqueue.length = 0;\n\t\t\t\treject(failure);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (closed) {\n\t\t\t\tresolve();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tobject = found;\n\t\t\tfound.message.connect(forward);\n\t\t\tfor (const text of queue.splice(0)) {\n\t\t\t\tfound.receive(text);\n\t\t\t}\n\t\t\tresolve();\n\t\t});\n\t});\n\treturn {\n\t\tready,\n\t\tsend(message: unknown): void {\n\t\t\tif (closed) {\n\t\t\t\tthrow new QgisSdkWebChannelError(\"the web channel transport is closed\");\n\t\t\t}\n\t\t\tif (failure !== null) {\n\t\t\t\tthrow failure;\n\t\t\t}\n\t\t\tconst text = JSON.stringify(message);\n\t\t\tif (object === null) {\n\t\t\t\tqueue.push(text);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tobject.receive(text);\n\t\t},\n\t\tsubscribe(listener: (message: unknown) => void): () => void {\n\t\t\tlisteners.add(listener);\n\t\t\treturn () => {\n\t\t\t\tlisteners.delete(listener);\n\t\t\t};\n\t\t},\n\t\tclose(): void {\n\t\t\tif (closed) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tclosed = true;\n\t\t\tqueue.length = 0;\n\t\t\tlisteners.clear();\n\t\t\tobject?.message.disconnect(forward);\n\t\t},\n\t};\n}\n",
    "/**\n * `QgisSdk`: the page-side object a plugin's web view talks to QGIS through.\n *\n * Three statements connect a page (decision-44):\n *\n * ```ts\n * import schema from \"./bridge.schema\";\n * const qgis = QgisSdk.fromBridgeSchema(schema);\n * await qgis.sites.summary({ layer_id });\n * ```\n *\n * The schema is the generated `bridge.schema.ts`: the plugin description plus\n * its `Operations` and `Streams` types. From the description the SDK builds\n * one method per declared action and stream, nested under the segments of its\n * id (`sites.summary` is `qgis.sites.summary`, `buffer` is `qgis.buffer`),\n * and checks every argument, reply and event against the declared schemas\n * with the same rules the host applies (`validate.ts`). From the types it gives those\n * methods their signatures, so a wrong argument shape or an unknown operation\n * is a compile error and a value outside the schema at run time is a\n * {@link QgisSdkContractError}.\n *\n * `host` is the curated host surface of decision-27, built on the same client,\n * plus `granted`: the host operation ids the handshake advertised for this\n * view. A call outside the grants is not refused here - the host refuses it,\n * and the page sees the host's `not_authorized` - but a page can read `granted`\n * after `ready` to hide what it may not use.\n */\n\nimport {\n\tBridgeClient,\n\ttype BridgeStreamTerminal,\n\ttype BridgeSubscription,\n\ttype InvokeOptions,\n\tQgisSdkBridgeProtocolError,\n\ttype WireTransport,\n} from \"./bridge\";\nimport {\n\ttype ActionDescription,\n\tQgisSdkDeclarationError,\n\ttype StreamDescription,\n} from \"./declarations\";\nimport {\n\tcreateHost,\n\tHOST_OPERATIONS,\n\ttype HostOperationId,\n\ttype HostOperations,\n} from \"./generated/host\";\nimport { isPlainRecord } from \"./internal\";\nimport type {\n\tBridgeSchema,\n\tOperationMap,\n\tOperationShape,\n\tStreamMap,\n\tStreamShape,\n} from \"./schema\";\nimport { QgisSdkContractError, validateAgainstSchema } from \"./validate\";\nimport { createWebChannelTransport } from \"./webchannel\";\n\n/** Options for {@link QgisSdk.fromBridgeSchema}. */\nexport interface QgisSdkOptions {\n\t/** A transport to speak through; defaults to the page's QWebChannel. */\n\treadonly transport?: WireTransport;\n\t/** A client the caller owns; `close()` leaves it open. Excludes `transport`. */\n\treadonly client?: BridgeClient;\n\t/** Per-call timeout for an owned client. */\n\treadonly timeoutMs?: number;\n\t/** The channel object's name when the default transport is used. */\n\treadonly channelObject?: string;\n}\n\n/** Handlers for a typed stream: events as declared, then exactly one end. */\nexport interface StreamHandlers<E> {\n\treadonly onEvent?: (event: E) => void;\n\treadonly onTerminal?: (terminal: BridgeStreamTerminal) => void;\n}\n\n/** A live stream, as the caller holds it. */\nexport type StreamHandle = BridgeSubscription;\n\n/** The method one declared action becomes; an empty request may be omitted. */\nexport type OperationMethod<Op extends OperationShape> =\n\t// biome-ignore lint/complexity/noBannedTypes: `{}` is the test for \"nothing required\"\n\t{} extends Op[\"request\"]\n\t\t? (\n\t\t\t\trequest?: Op[\"request\"],\n\t\t\t\toptions?: InvokeOptions,\n\t\t\t) => Promise<Op[\"result\"]>\n\t\t: (\n\t\t\t\trequest: Op[\"request\"],\n\t\t\t\toptions?: InvokeOptions,\n\t\t\t) => Promise<Op[\"result\"]>;\n\n/** The method one declared stream becomes. */\nexport type StreamMethod<St extends StreamShape> = (\n\trequest: St[\"request\"],\n\thandlers: StreamHandlers<St[\"event\"]>,\n\toptions?: InvokeOptions,\n) => Promise<StreamHandle>;\n\n/**\n * The running palette, when the handshake carried one (decision-16): the\n * `QPalette` colour roles the host read, as CSS hex (`#rrggbb` or\n * `#rrggbbaa`) by their camel-cased role name, and whether the window colour\n * is dark. `qgis-sdk-ui` turns it into the `--qgis-sdk-*` custom properties;\n * a page outside QGIS sees `null` and keeps the documented defaults.\n */\nexport interface QgisSdkHostTheme {\n\treadonly palette: Readonly<Record<string, string>>;\n\treadonly dark: boolean;\n}\n\n/** What the handshake told this page about the host (decision-27). */\nexport interface QgisSdkHost extends HostOperations {\n\t/**\n\t * The host operation ids the handshake advertised for this view; empty\n\t * until {@link QgisSdkCore.ready} has resolved.\n\t */\n\treadonly granted: readonly HostOperationId[];\n\t/**\n\t * The host's palette, `null` until {@link QgisSdkCore.ready} has resolved\n\t * and when the host sent none.\n\t */\n\treadonly theme: QgisSdkHostTheme | null;\n}\n\n/** The members every `QgisSdk` has, whatever its schema declares. */\nexport interface QgisSdkCore<O = OperationMap, S = StreamMap> {\n\t/** The schema this instance was built from. */\n\treadonly schema: BridgeSchema<O, S>;\n\t/** The client under the methods, for what a method does not cover. */\n\treadonly client: BridgeClient;\n\t/** The curated host surface, and what this view was granted of it. */\n\treadonly host: QgisSdkHost;\n\t/** Resolves once the handshake answered; rejects when the host refused it. */\n\treadonly ready: Promise<void>;\n\t/** Close an owned client; a client the caller passed in is left alone. */\n\tclose(): void;\n}\n\n/** The first segment of a dotted id, or the whole id when it has none. */\ntype Head<K extends string> = K extends `${infer H}.${string}` ? H : K;\n\n/** The members of `M` under one head, keyed by the rest of their ids. */\ntype Under<M, H extends string> = {\n\t[K in keyof M & string as K extends `${H}.${infer Rest}`\n\t\t? Rest\n\t\t: never]: M[K];\n};\n\n/**\n * The declared actions as a tree: a plain id is a method, a dotted id nests\n * one object per segment. An id that is both a leaf and a prefix of another\n * is refused at run time, so the type need not say what it would mean.\n */\nexport type OperationTree<O> = {\n\treadonly [H in Head<keyof O & string>]: H extends keyof O\n\t\t? O[H] extends OperationShape\n\t\t\t? OperationMethod<O[H]>\n\t\t\t: never\n\t\t: OperationTree<Under<O, H>>;\n};\n\n/** The declared streams as the same tree, with a stream method at each leaf. */\nexport type StreamTree<S> = {\n\treadonly [H in Head<keyof S & string>]: H extends keyof S\n\t\t? S[H] extends StreamShape\n\t\t\t? StreamMethod<S[H]>\n\t\t\t: never\n\t\t: StreamTree<Under<S, H>>;\n};\n\n/**\n * A page's handle on QGIS: the core, plus one method per declared operation\n * nested under the segments of its id.\n */\nexport type QgisSdk<O = OperationMap, S = StreamMap> = QgisSdkCore<O, S> &\n\tOperationTree<O> &\n\tStreamTree<S>;\n\n/** Names {@link QgisSdkCore} keeps; a declared id may not start with one. */\nexport const QGIS_SDK_MEMBERS: readonly string[] = Object.freeze([\n\t\"client\",\n\t\"host\",\n\t\"schema\",\n\t\"ready\",\n\t\"close\",\n]);\n\nconst HOST_IDS: ReadonlySet<string> = new Set<string>(HOST_OPERATIONS);\n\n/** The handshake, as far as this module reads it. */\ninterface Handshake {\n\treadonly operations: readonly string[];\n\treadonly granted: readonly HostOperationId[];\n\treadonly theme: QgisSdkHostTheme | null;\n}\n\nfunction parseHandshake(value: unknown): Handshake {\n\tif (!isPlainRecord(value) || !Array.isArray(value.operations)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\"The handshake reply carries no operations list\",\n\t\t);\n\t}\n\tconst operations: string[] = [];\n\tfor (const operation of value.operations) {\n\t\tif (isPlainRecord(operation) && typeof operation.id === \"string\") {\n\t\t\toperations.push(operation.id);\n\t\t}\n\t}\n\treturn {\n\t\toperations,\n\t\tgranted: Object.freeze(\n\t\t\toperations.filter((id): id is HostOperationId => HOST_IDS.has(id)),\n\t\t),\n\t\ttheme: parseTheme(value.theme),\n\t};\n}\n\n/**\n * The `theme` of a handshake, or `null` when absent or malformed: a palette\n * that cannot be read is no reason to refuse the host, the page just keeps\n * its defaults. Only string colours are kept.\n */\nfunction parseTheme(value: unknown): QgisSdkHostTheme | null {\n\tif (!isPlainRecord(value) || !isPlainRecord(value.palette)) {\n\t\treturn null;\n\t}\n\tconst palette: Record<string, string> = {};\n\tfor (const [role, colour] of Object.entries(value.palette)) {\n\t\tif (typeof colour === \"string\") {\n\t\t\tpalette[role] = colour;\n\t\t}\n\t}\n\treturn Object.freeze({\n\t\tpalette: Object.freeze(palette),\n\t\tdark: value.dark === true,\n\t});\n}\n\nfunction unwrapRequest(\n\toperation: string,\n\trequest: unknown,\n): Record<string, unknown> {\n\tif (request === undefined) {\n\t\treturn {};\n\t}\n\tif (!isPlainRecord(request)) {\n\t\tthrow new QgisSdkContractError(operation, \"request\", [\n\t\t\t...validateAgainstSchema(request, { type: \"object\" }),\n\t\t]);\n\t}\n\treturn request;\n}\n\nfunction checkedRequest(\n\tdescription: ActionDescription | StreamDescription,\n\trequest: unknown,\n): Record<string, unknown> {\n\tconst payload = unwrapRequest(description.id, request);\n\tconst issues = validateAgainstSchema(payload, description.request);\n\tif (issues.length > 0) {\n\t\tthrow new QgisSdkContractError(description.id, \"request\", issues);\n\t}\n\treturn payload;\n}\n\nfunction operationMethod(\n\tclient: BridgeClient,\n\taction: ActionDescription,\n): (request?: unknown, options?: InvokeOptions) => Promise<unknown> {\n\treturn async (request, options) => {\n\t\tconst payload = checkedRequest(action, request);\n\t\tconst value = await client.invoke(action.id, payload, options);\n\t\tconst issues = validateAgainstSchema(value, action.result, {\n\t\t\tallowUnknown: true,\n\t\t});\n\t\tif (issues.length > 0) {\n\t\t\tthrow new QgisSdkContractError(action.id, \"result\", issues);\n\t\t}\n\t\treturn value;\n\t};\n}\n\nfunction streamMethod(\n\tclient: BridgeClient,\n\tstream: StreamDescription,\n): (\n\trequest: unknown,\n\thandlers: StreamHandlers<unknown>,\n\toptions?: InvokeOptions,\n) => Promise<StreamHandle> {\n\treturn async (request, handlers, options) => {\n\t\tconst payload = checkedRequest(stream, request);\n\t\t// The typed stream ends exactly once, like the subscription under it: a\n\t\t// contract violation ends it here, closes the subscription, and the\n\t\t// `disposed` the client then reports is not delivered a second time.\n\t\tlet ended = false;\n\t\tlet violated = false;\n\t\tlet handle: StreamHandle | null = null;\n\t\tconst end = (terminal: BridgeStreamTerminal): void => {\n\t\t\tif (ended) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tended = true;\n\t\t\thandlers.onTerminal?.(terminal);\n\t\t};\n\t\thandle = await client.subscribe(\n\t\t\tstream.id,\n\t\t\tpayload,\n\t\t\t{\n\t\t\t\tonEvent: (event) => {\n\t\t\t\t\tif (ended) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst declared = stream.events[event.kind];\n\t\t\t\t\tconst issues =\n\t\t\t\t\t\tdeclared === undefined\n\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t: validateAgainstSchema(event.payload, declared, {\n\t\t\t\t\t\t\t\t\tallowUnknown: true,\n\t\t\t\t\t\t\t\t\tpath: [\"payload\"],\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\tif (issues !== undefined && issues.length === 0) {\n\t\t\t\t\t\thandlers.onEvent?.(event);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst error = new QgisSdkContractError(\n\t\t\t\t\t\tstream.id,\n\t\t\t\t\t\t\"event\",\n\t\t\t\t\t\tissues ?? [],\n\t\t\t\t\t);\n\t\t\t\t\tend({ kind: \"error\", message: error.message });\n\t\t\t\t\tif (handle === null) {\n\t\t\t\t\t\tviolated = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\thandle.close();\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tonTerminal: end,\n\t\t\t},\n\t\t\toptions,\n\t\t);\n\t\tif (violated) {\n\t\t\thandle.close();\n\t\t}\n\t\treturn handle;\n\t};\n}\n\nfunction buildHost(\n\tclient: BridgeClient,\n\thandshake: () => Handshake | null,\n): QgisSdkHost {\n\tconst host = createHost(client);\n\treturn Object.freeze({\n\t\t...host,\n\t\tget granted(): readonly HostOperationId[] {\n\t\t\treturn granted(handshake());\n\t\t},\n\t\tget theme(): QgisSdkHostTheme | null {\n\t\t\treturn handshake()?.theme ?? null;\n\t\t},\n\t});\n}\n\nconst NO_GRANTS: readonly HostOperationId[] = Object.freeze([]);\n\nfunction granted(handshake: Handshake | null): readonly HostOperationId[] {\n\treturn handshake === null ? NO_GRANTS : handshake.granted;\n}\n\nfunction build<O, S>(\n\tschema: BridgeSchema<O, S>,\n\toptions: QgisSdkOptions,\n): QgisSdk<O, S> {\n\tif (options.client !== undefined && options.transport !== undefined) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\"QgisSdk.fromBridgeSchema takes a client or a transport, not both\",\n\t\t);\n\t}\n\tconst owned = options.client === undefined;\n\tconst transport =\n\t\toptions.transport ??\n\t\t(options.client === undefined\n\t\t\t? createWebChannelTransport(options.channelObject ?? \"bridge\")\n\t\t\t: undefined);\n\tconst client =\n\t\toptions.client ??\n\t\tnew BridgeClient(\n\t\t\ttransport as WireTransport,\n\t\t\toptions.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs },\n\t\t);\n\tlet handshake: Handshake | null = null;\n\tconst ready = client.handshake().then((value) => {\n\t\thandshake = parseHandshake(value);\n\t});\n\t// A page that never awaits `ready` still sees every call fail on its own;\n\t// the rejection is not left unobserved on top of that.\n\tready.catch(() => undefined);\n\tconst members: Record<string, unknown> = {\n\t\tschema,\n\t\tclient,\n\t\thost: buildHost(client, () => handshake),\n\t\tready,\n\t\tclose: (): void => {\n\t\t\tif (owned) {\n\t\t\t\tclient.close();\n\t\t\t}\n\t\t},\n\t};\n\tconst namespaces: Record<string, unknown>[] = [];\n\tfor (const action of schema.actions) {\n\t\tplace(members, namespaces, action.id, operationMethod(client, action));\n\t}\n\tfor (const stream of schema.streams) {\n\t\tplace(members, namespaces, stream.id, streamMethod(client, stream));\n\t}\n\tfor (const namespace of namespaces) {\n\t\tObject.freeze(namespace);\n\t}\n\treturn Object.freeze(members) as unknown as QgisSdk<O, S>;\n}\n\n/**\n * Put one method where its id says: `a.b.c` becomes `members.a.b.c`, building\n * the objects on the way. Two ids cannot both be honest when one is a prefix\n * of the other - `sites` cannot be a method and hold `sites.summary` - and a\n * first segment that is a core member would hide it, so both are refused.\n */\nfunction place(\n\tmembers: Record<string, unknown>,\n\tnamespaces: Record<string, unknown>[],\n\tid: string,\n\tmethod: unknown,\n): void {\n\tconst segments = id.split(\".\");\n\tif (segments.some((segment) => segment === \"\")) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: an operation id may not have an empty segment`,\n\t\t);\n\t}\n\tconst head = segments[0] as string;\n\tif (QGIS_SDK_MEMBERS.includes(head)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: an operation id may not start with a QgisSdk member (${QGIS_SDK_MEMBERS.join(\", \")})`,\n\t\t);\n\t}\n\tlet node = members;\n\tfor (const [index, segment] of segments.entries()) {\n\t\tconst prefix = segments.slice(0, index + 1).join(\".\");\n\t\tconst existing = node[segment];\n\t\tif (index === segments.length - 1) {\n\t\t\tif (existing !== undefined) {\n\t\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t\ttypeof existing === \"function\"\n\t\t\t\t\t\t? `${id}: duplicate operation id`\n\t\t\t\t\t\t: `${id}: an operation id may not be a prefix of another declared id`,\n\t\t\t\t);\n\t\t\t}\n\t\t\tnode[segment] = method;\n\t\t\treturn;\n\t\t}\n\t\tif (existing === undefined) {\n\t\t\tconst namespace: Record<string, unknown> = {};\n\t\t\tnamespaces.push(namespace);\n\t\t\tnode[segment] = namespace;\n\t\t\tnode = namespace;\n\t\t} else if (typeof existing === \"function\") {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${id}: ${prefix} is already an operation id; an id may not extend another`,\n\t\t\t);\n\t\t} else {\n\t\t\tnode = existing as Record<string, unknown>;\n\t\t}\n\t}\n}\n\n/**\n * The entry point: `QgisSdk.fromBridgeSchema(schema)`.\n *\n * A namespace rather than a constant so the value and the instance type share\n * one name through every declaration bundler.\n */\nexport namespace QgisSdk {\n\t/**\n\t * Build a `QgisSdk` on a generated schema.\n\t *\n\t * Without options it connects to the page's QWebChannel object named\n\t * \"bridge\", which is what the Python runtime registers; a test passes the\n\t * harness from `@archont561/qgis-sdk/testing` as `transport` instead.\n\t */\n\texport function fromBridgeSchema<\n\t\tO extends Record<keyof O, OperationShape>,\n\t\tS extends Record<keyof S, StreamShape>,\n\t>(schema: BridgeSchema<O, S>, options: QgisSdkOptions = {}): QgisSdk<O, S> {\n\t\treturn build(schema, options);\n\t}\n}\n",
    "/**\n * The bridge schema: a plugin description that also carries its types.\n *\n * `qgis-sdk bridge generate` writes one `bridge.schema.ts` per plugin\n * (decision-44). That module has no code of its own: it declares the value\n * interfaces, two maps - `Operations` and `Streams`, keyed by operation id -\n * and ends in `defineBridgeSchema<Operations, Streams>({ ...description })`.\n * The two type parameters never exist at run time; they ride on the returned\n * object so `QgisSdk.fromBridgeSchema(schema)` can infer them, and the\n * description itself is what the SDK validates against.\n */\n\nimport { type PluginDescription, parsePluginDescription } from \"./declarations\";\n\n/** What one declared action promises: an object in, a value out. */\nexport interface OperationShape {\n\treadonly request: object;\n\treadonly result: unknown;\n}\n\n/** What one declared stream promises: an object in, discriminated events out. */\nexport interface StreamShape {\n\treadonly request: object;\n\treadonly event: { readonly kind: string; readonly payload: unknown };\n}\n\n/** The default, untyped map: any id, any shape. */\nexport type OperationMap = { readonly [id: string]: OperationShape };\n\n/** The default, untyped map: any id, any shape. */\nexport type StreamMap = { readonly [id: string]: StreamShape };\n\n/**\n * A parsed plugin description carrying its `Operations` and `Streams` types.\n *\n * The `\"~types\"` member is compile-time only: it is never set, and a schema is\n * a frozen {@link PluginDescription} and nothing more at run time. It is a\n * string key, not a unique symbol, so the type stays structurally the same\n * across the package's entry points.\n */\nexport interface BridgeSchema<O = OperationMap, S = StreamMap>\n\textends PluginDescription {\n\treadonly \"~types\"?: {\n\t\treadonly operations: O;\n\t\treadonly streams: S;\n\t};\n}\n\n/** The `Operations` map a schema carries. */\nexport type OperationsOf<Schema> =\n\tSchema extends BridgeSchema<infer O, unknown> ? O : never;\n\n/** The `Streams` map a schema carries. */\nexport type StreamsOf<Schema> =\n\tSchema extends BridgeSchema<unknown, infer S> ? S : never;\n\n/**\n * Parse a description and type it; the generated module is the only caller.\n *\n * The description is checked the way any description is (`schema_version`,\n * ids, handlers, declared streams), so a hand-edited or stale module fails\n * here, at import, rather than on the first call.\n */\nexport function defineBridgeSchema<\n\tO extends Record<keyof O, OperationShape>,\n\tS extends Record<keyof S, StreamShape>,\n>(input: string | Readonly<Record<string, unknown>>): BridgeSchema<O, S> {\n\treturn parsePluginDescription(input) as BridgeSchema<O, S>;\n}\n"
  ],
  "mappings": "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",
  "debugId": "507C47A54A87BD1B64756E2164756E21",
  "names": []
}