@archont561/qgis-sdk-bridge 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# @archont561/qgis-sdk-bridge
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**TypeScript contract, wire-limit, and error primitives for QGIS `QWebEngineView` plugin interfaces.**
+
+`@archont561/qgis-sdk-bridge` is the TypeScript companion package to [`qgis-sdk`](https://pypi.org/project/qgis-sdk/) in the [QGIS SDK workspace](https://github.com/Archont561/qgis-sdk).
+
+> **Status (`0.1.0` experimental):** Exposes the version 1 plugin/action declaration parser (`parsePluginDescription`, `PluginDescription`, `ActionDescription`), JavaScript-safe integer wire bounds (`MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `isSafeJsonInteger`), and the `QgisSdk*`-prefixed error hierarchy (`QgisSdkError`, `QgisSdkScopeClosedError`, `QgisSdkUnsupportedCapabilityError`, `QgisSdkDeclarationError`, `QgisSdkContractValidationError`, `QgisSdkValidationIssue`). `QWebChannel` transport bindings, generated operation clients, and React hooks are scheduled for subsequent `0.x` milestones.
+
+## Exports
+
+```ts
+import {
+	MAX_SAFE_INTEGER,
+	MIN_SAFE_INTEGER,
+	PLUGIN_DESCRIPTION_SCHEMA_VERSION,
+	QgisSdkContractValidationError,
+	QgisSdkDeclarationError,
+	QgisSdkError,
+	QgisSdkScopeClosedError,
+	QgisSdkUnsupportedCapabilityError,
+	QgisSdkValidationIssue,
+	isSafeJsonInteger,
+	parsePluginDescription,
+} from "@archont561/qgis-sdk-bridge";
+```
+
+- **Safe integer bounds:** `MAX_SAFE_INTEGER` (`9007199254740991`), `MIN_SAFE_INTEGER` (`-9007199254740991`), and `isSafeJsonInteger(value)` mirror `qgis_sdk.models.MAX_SAFE_INTEGER` and `SafeJsonInteger`.
+- **Version 1 plugin descriptions:** `parsePluginDescription(raw)` validates and freezes `PluginDescription` payloads (`schema_version: 1`) produced by Python's `describe_plugin(cls).to_json()`.
+- **Structured SDK errors:** Every SDK exception class begins with `QgisSdk` and carries a stable wire `code` property (`"sdk_error"`, `"scope_closed"`, `"unsupported_capability"`, `"invalid_declaration"`, `"contract_validation_failed"`).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+/**
+* Public 0.1.0 contract, wire-limit, and error primitives for the QGIS SDK bridge.
+*
+* Mirrors the QGIS-free `qgis_sdk.models` and `qgis_sdk.declarations`
+* (`schema_version = 1`) contracts without importing browser or Qt globals.
+*/
+declare const MAX_SAFE_INTEGER: number;
+declare const MIN_SAFE_INTEGER: number;
+declare const PLUGIN_DESCRIPTION_SCHEMA_VERSION: 1;
+type ValidationDirection = "request" | "result";
+interface SerializedValidationIssue {
+	readonly path: (string | number)[];
+	readonly code: string;
+}
+interface SerializedContractValidationError {
+	readonly code: string;
+	readonly direction: ValidationDirection;
+	readonly issues: SerializedValidationIssue[];
+}
+interface ActionDescription {
+	readonly id: string;
+	readonly title: string;
+	readonly handler: string;
+	readonly request: Readonly<Record<string, unknown>>;
+	readonly result: Readonly<Record<string, unknown>>;
+}
+interface PluginDescription {
+	readonly schema_version: 1;
+	readonly id: string;
+	readonly title: string;
+	readonly actions: readonly ActionDescription[];
+}
+/**
+* Return whether `value` is a finite integer within the JavaScript-safe wire range.
+*/
+declare function isSafeJsonInteger(value: unknown): value is number;
+/**
+* Base class for expected SDK errors across the bridge boundary.
+*/
+declare class QgisSdkError extends Error {
+	readonly code: string;
+	constructor(message: string, code?: string);
+}
+/**
+* An operation attempted to use an already disposed owner scope.
+*/
+declare class QgisSdkScopeClosedError extends QgisSdkError {
+	constructor();
+}
+/**
+* The selected runtime does not offer an explicitly requested capability.
+*/
+declare class QgisSdkUnsupportedCapabilityError extends QgisSdkError {
+	readonly capability: string;
+	constructor(capability: string);
+}
+/**
+* A declaration cannot be represented or parsed in the versioned contract.
+*/
+declare class QgisSdkDeclarationError extends QgisSdkError {
+	constructor(message: string);
+}
+/**
+* Safe, structured location and category for a rejected contract value.
+*/
+declare class QgisSdkValidationIssue {
+	readonly path: readonly (string | number)[];
+	readonly code: string;
+	constructor(path: readonly (string | number)[], code: string);
+	toJSON(): SerializedValidationIssue;
+}
+/**
+* A request or result did not satisfy its declared wire contract.
+*/
+declare class QgisSdkContractValidationError extends QgisSdkError {
+	readonly direction: ValidationDirection;
+	readonly issues: readonly QgisSdkValidationIssue[];
+	constructor(direction: ValidationDirection, issues: readonly QgisSdkValidationIssue[]);
+	toJSON(): SerializedContractValidationError;
+}
+/**
+* Parse and validate a version 1 `PluginDescription` emitted by `describe_plugin`.
+*/
+declare function parsePluginDescription(input: string | Readonly<Record<string, unknown>>): PluginDescription;
+export { ActionDescription, MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, PLUGIN_DESCRIPTION_SCHEMA_VERSION, PluginDescription, QgisSdkContractValidationError, QgisSdkDeclarationError, QgisSdkError, QgisSdkScopeClosedError, QgisSdkUnsupportedCapabilityError, QgisSdkValidationIssue, SerializedContractValidationError, SerializedValidationIssue, ValidationDirection, isSafeJsonInteger, parsePluginDescription };

package/dist/index.js

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

package/package.json

@@ -1,6 +1,35 @@
 {
-  "name": "@archont561/qgis-sdk-bridge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@archont561/qgis-sdk-bridge",
+	"version": "0.1.0",
+	"description": "TypeScript bridge contracts and error primitives for QGIS SDK WebEngine plugin interfaces.",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Archont561/qgis-sdk.git",
+		"directory": "packages/qgis-sdk-bridge"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bunup",
+		"test": "bun test",
+		"coverage": "bun --cwd=../.. --config=bunfig.toml test --coverage packages/qgis-sdk-bridge/tests",
+		"typecheck": "tsc --noEmit",
+		"generate:contract-types": "json2ts -i 'tests/contracts/generated/schemas/*.json' -o tests/contracts/generated/types/ && json2ts -i 'tests/contracts/pydantic/generated/schemas/*.json' -o tests/contracts/pydantic/generated/types/"
+	}
+}