@archont561/qgis-sdk-bridge 0.1.1 → 0.2.0

package/dist/shared/chunk-0fknax6w.js

@@ -0,0 +1,207 @@
+// src/index.ts
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+var MIN_SAFE_INTEGER2 = -9007199254740991;
+var PLUGIN_DESCRIPTION_SCHEMA_VERSION2 = 1;
+var STREAM_EVENT_KINDS = [
+  "data",
+  "progress",
+  "state"
+];
+function isSafeJsonInteger2(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+
+class QgisSdkError2 extends Error {
+  code;
+  constructor(message, code = "sdk_error") {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+  }
+}
+
+class QgisSdkScopeClosedError2 extends QgisSdkError2 {
+  constructor() {
+    super("This resource scope has been disposed", "scope_closed");
+  }
+}
+
+class QgisSdkUnsupportedCapabilityError2 extends QgisSdkError2 {
+  capability;
+  constructor(capability) {
+    super(`Capability ${JSON.stringify(capability)} is unavailable in this runtime`, "unsupported_capability");
+    this.capability = capability;
+  }
+}
+
+class QgisSdkDeclarationError2 extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "invalid_declaration");
+  }
+}
+
+class QgisSdkValidationIssue2 {
+  path;
+  code;
+  constructor(path, code) {
+    this.path = Object.freeze([...path]);
+    this.code = code;
+  }
+  toJSON() {
+    return {
+      path: [...this.path],
+      code: this.code
+    };
+  }
+}
+
+class QgisSdkContractValidationError2 extends QgisSdkError2 {
+  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 isPlainRecord2(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 QgisSdkDeclarationError2(`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 QgisSdkDeclarationError2(`${id}: title must be a nonempty string`);
+  }
+  return value;
+}
+function parseOperationHead(raw, label) {
+  if (!isPlainRecord2(raw)) {
+    throw new QgisSdkDeclarationError2(`${label[0]?.toUpperCase()}${label.slice(1)} description must be an object`);
+  }
+  const id = validateDeclarationId(raw.id, label);
+  const title = validateNonBlankTitle(raw.title, id);
+  if (typeof raw.handler !== "string" || !PYTHON_IDENTIFIER_PATTERN.test(raw.handler)) {
+    throw new QgisSdkDeclarationError2(`${id}: handler must be a valid Python identifier`);
+  }
+  if (!isPlainRecord2(raw.request)) {
+    throw new QgisSdkDeclarationError2(`${id}: request schema must be an object`);
+  }
+  return {
+    raw,
+    id,
+    title,
+    handler: raw.handler,
+    request: Object.freeze({ ...raw.request })
+  };
+}
+function parseActionDescription(raw) {
+  const head = parseOperationHead(raw, "action");
+  if (!isPlainRecord2(head.raw.result)) {
+    throw new QgisSdkDeclarationError2(`${head.id}: result schema must be an object`);
+  }
+  return Object.freeze({
+    id: head.id,
+    title: head.title,
+    handler: head.handler,
+    request: head.request,
+    result: Object.freeze({ ...head.raw.result })
+  });
+}
+function parseStreamDescription(raw) {
+  const head = parseOperationHead(raw, "stream");
+  const declared = head.raw.events;
+  if (!isPlainRecord2(declared) || Object.keys(declared).length === 0) {
+    throw new QgisSdkDeclarationError2(`${head.id}: events must map at least one event kind to a schema`);
+  }
+  const events = {};
+  for (const [kind, schema] of Object.entries(declared)) {
+    if (!STREAM_EVENT_KINDS.includes(kind)) {
+      throw new QgisSdkDeclarationError2(`${head.id}: ${kind} is not a stream event kind`);
+    }
+    if (!isPlainRecord2(schema)) {
+      throw new QgisSdkDeclarationError2(`${head.id}: events.${kind} schema must be an object`);
+    }
+    events[kind] = Object.freeze({ ...schema });
+  }
+  return Object.freeze({
+    id: head.id,
+    title: head.title,
+    handler: head.handler,
+    request: head.request,
+    events: Object.freeze(events)
+  });
+}
+function parsePluginDescription2(input) {
+  let parsed = input;
+  if (typeof input === "string") {
+    try {
+      parsed = JSON.parse(input);
+    } catch {
+      throw new QgisSdkDeclarationError2("Plugin description is not valid JSON");
+    }
+  }
+  if (!isPlainRecord2(parsed)) {
+    throw new QgisSdkDeclarationError2("Plugin description must be an object");
+  }
+  if (parsed.schema_version !== PLUGIN_DESCRIPTION_SCHEMA_VERSION2) {
+    throw new QgisSdkDeclarationError2(`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 QgisSdkDeclarationError2(`${id}: actions must be an array`);
+  }
+  const declaredStreams = parsed.streams ?? [];
+  if (!Array.isArray(declaredStreams)) {
+    throw new QgisSdkDeclarationError2(`${id}: streams must be an array`);
+  }
+  const seenIds = new Set;
+  const claim = (operationId, label) => {
+    if (seenIds.has(operationId)) {
+      throw new QgisSdkDeclarationError2(`${id}: duplicate ${label} id ${operationId}`);
+    }
+    seenIds.add(operationId);
+  };
+  const actions = [];
+  for (const item of parsed.actions) {
+    const action = parseActionDescription(item);
+    claim(action.id, "action");
+    actions.push(action);
+  }
+  const streams = [];
+  for (const item of declaredStreams) {
+    const stream = parseStreamDescription(item);
+    claim(stream.id, "stream");
+    streams.push(stream);
+  }
+  const byId = (left, right) => left.id < right.id ? -1 : 1;
+  actions.sort(byId);
+  streams.sort(byId);
+  return Object.freeze({
+    schema_version: PLUGIN_DESCRIPTION_SCHEMA_VERSION2,
+    id,
+    title,
+    actions: Object.freeze(actions),
+    streams: Object.freeze(streams)
+  });
+}
+
+export { MAX_SAFE_INTEGER2, MIN_SAFE_INTEGER2, PLUGIN_DESCRIPTION_SCHEMA_VERSION2, isSafeJsonInteger2, QgisSdkError2, QgisSdkScopeClosedError2, QgisSdkUnsupportedCapabilityError2, QgisSdkDeclarationError2, QgisSdkValidationIssue2, QgisSdkContractValidationError2, isPlainRecord2, parsePluginDescription2 };
+
+//# debugId=BF5795AE7CCB0B5464756E2164756E21
+//# 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\n/** The event kinds a stream may declare; the frame carries the same three. */\nexport type StreamEventKind = \"data\" | \"progress\" | \"state\";\n\n/**\n * A declared stream (decision-28): a request in, one payload schema per\n * declared event kind out. There is no `result`: the reply to a subscription is\n * the protocol's acknowledgement, not something an author declares.\n */\nexport interface StreamDescription {\n\treadonly id: string;\n\treadonly title: string;\n\treadonly handler: string;\n\treadonly request: Readonly<Record<string, unknown>>;\n\treadonly events: Readonly<\n\t\tPartial<Record<StreamEventKind, Readonly<Record<string, unknown>>>>\n\t>;\n}\n\nexport interface PluginDescription {\n\treadonly schema_version: 1;\n\treadonly id: string;\n\treadonly title: string;\n\treadonly actions: readonly ActionDescription[];\n\t/** Declared streams; a description from a host that predates them is empty. */\n\treadonly streams: readonly StreamDescription[];\n}\n\nconst STREAM_EVENT_KINDS: readonly StreamEventKind[] = [\n\t\"data\",\n\t\"progress\",\n\t\"state\",\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\n/**\n * Return whether `value` is a non-null, non-array object: the shape every wire\n * envelope, description and event payload must have before its fields are read.\n */\nexport function isPlainRecord(\n\tvalue: unknown,\n): 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 parseOperationHead(\n\traw: unknown,\n\tlabel: string,\n): {\n\treadonly raw: Record<string, unknown>;\n\treadonly id: string;\n\treadonly title: string;\n\treadonly handler: string;\n\treadonly request: Readonly<Record<string, unknown>>;\n} {\n\tif (!isPlainRecord(raw)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${label[0]?.toUpperCase()}${label.slice(1)} description must be an object`,\n\t\t);\n\t}\n\tconst id = validateDeclarationId(raw.id, label);\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\treturn {\n\t\traw,\n\t\tid,\n\t\ttitle,\n\t\thandler: raw.handler,\n\t\trequest: Object.freeze({ ...raw.request }),\n\t};\n}\n\nfunction parseActionDescription(raw: unknown): ActionDescription {\n\tconst head = parseOperationHead(raw, \"action\");\n\tif (!isPlainRecord(head.raw.result)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${head.id}: result schema must be an object`,\n\t\t);\n\t}\n\treturn Object.freeze({\n\t\tid: head.id,\n\t\ttitle: head.title,\n\t\thandler: head.handler,\n\t\trequest: head.request,\n\t\tresult: Object.freeze({ ...head.raw.result }),\n\t});\n}\n\nfunction parseStreamDescription(raw: unknown): StreamDescription {\n\tconst head = parseOperationHead(raw, \"stream\");\n\tconst declared = head.raw.events;\n\tif (!isPlainRecord(declared) || Object.keys(declared).length === 0) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${head.id}: events must map at least one event kind to a schema`,\n\t\t);\n\t}\n\tconst events: Partial<\n\t\tRecord<StreamEventKind, Readonly<Record<string, unknown>>>\n\t> = {};\n\tfor (const [kind, schema] of Object.entries(declared)) {\n\t\tif (!STREAM_EVENT_KINDS.includes(kind as StreamEventKind)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${head.id}: ${kind} is not a stream event kind`,\n\t\t\t);\n\t\t}\n\t\tif (!isPlainRecord(schema)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${head.id}: events.${kind} schema must be an object`,\n\t\t\t);\n\t\t}\n\t\tevents[kind as StreamEventKind] = Object.freeze({ ...schema });\n\t}\n\treturn Object.freeze({\n\t\tid: head.id,\n\t\ttitle: head.title,\n\t\thandler: head.handler,\n\t\trequest: head.request,\n\t\tevents: Object.freeze(events),\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 declaredStreams = parsed.streams ?? [];\n\tif (!Array.isArray(declaredStreams)) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: streams must be an array`);\n\t}\n\t// Actions and streams share one id namespace (decision-28).\n\tconst seenIds = new Set<string>();\n\tconst claim = (operationId: string, label: string): void => {\n\t\tif (seenIds.has(operationId)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${id}: duplicate ${label} id ${operationId}`,\n\t\t\t);\n\t\t}\n\t\tseenIds.add(operationId);\n\t};\n\tconst actions: ActionDescription[] = [];\n\tfor (const item of parsed.actions) {\n\t\tconst action = parseActionDescription(item);\n\t\tclaim(action.id, \"action\");\n\t\tactions.push(action);\n\t}\n\tconst streams: StreamDescription[] = [];\n\tfor (const item of declaredStreams) {\n\t\tconst stream = parseStreamDescription(item);\n\t\tclaim(stream.id, \"stream\");\n\t\tstreams.push(stream);\n\t}\n\tconst byId = (\n\t\tleft: { readonly id: string },\n\t\tright: { readonly id: string },\n\t): number => (left.id < right.id ? -1 : 1);\n\tactions.sort(byId);\n\tstreams.sort(byId);\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\tstreams: Object.freeze(streams),\n\t});\n}\n"
  ],
  "mappings": "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",
  "debugId": "BF5795AE7CCB0B5464756E2164756E21",
  "names": []
}