@parity/product-sdk-host 0.10.3 → 0.12.0

package/src/theme.ts

@@ -1,74 +1,52 @@
 // Copyright 2026 Parity Technologies (UK) Ltd.
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Higher-level wrapper for the host's theme subscription.
+ * Higher-level wrapper for the host's theme subscription, backed by
+ * `truApi.theme.subscribe`.
  *
- * `hostApi.themeSubscribe` is reachable via {@link getTruApi}, but consumers
- * have to wire the subscription envelope themselves. `getThemeProvider`
- * returns the `@novasamatech/host-api-wrapper` theme provider object directly,
- * giving callers a `subscribeTheme(cb)` method that resolves to a typed
- * {@link ThemeMode} — a `{ name, variant }` struct where `variant` is
- * `"Light" | "Dark"` — and yields a `Subscription<void>` handle.
- *
- * @remarks
- * As of `host-api(-wrapper)` v0.8 the theme payload is a struct, not a flat
- * `"light" | "dark"` string: read {@link ThemeMode.variant} for the
- * light/dark value (now capitalized) and {@link ThemeMode.name} for the
- * active theme name (`Default`, or `Custom` carrying a string id).
+ * `getThemeProvider` returns a handle whose `subscribeTheme(cb)` delivers a
+ * typed {@link ThemeMode} — a `{ name, variant }` struct where `variant` is
+ * `"Light" | "Dark"` and `name` is `{ tag: "Default" }` or
+ * `{ tag: "Custom", value }` — and yields a {@link HostSubscription}
+ * (`unsubscribe` + `onInterrupt`).
  *
  * @module
  */
 
-import { createLogger } from "@parity/product-sdk-logger";
-
-import type {
-    createThemeProvider,
-    ThemeMode as NovasamaThemeMode,
-} from "@novasamatech/host-api-wrapper";
-
-const log = createLogger("host:theme");
+import type { HostThemeSubscribeItem, TrUApiClient } from "@parity/truapi";
 
-/**
- * Host theme provider handle. Exposes `subscribeTheme(callback)` which
- * receives a typed {@link ThemeMode} struct on every change and returns a
- * `Subscription<void>` (`unsubscribe` + `onInterrupt`).
- *
- * Type identical to `createThemeProvider()` from
- * `@novasamatech/host-api-wrapper`.
- */
-export type ThemeProvider = ReturnType<typeof createThemeProvider>;
+import { getClient, subscribeWithInterrupt } from "./transport.js";
+import type { HostSubscription } from "./types.js";
 
 /**
- * Host theme value. Re-exported from `@novasamatech/host-api-wrapper`.
- *
- * A `{ name, variant }` struct as of v0.8 (previously a flat
- * `"light" | "dark"` string).
+ * Host theme value. A `{ name, variant }` struct re-exported from
+ * `@parity/truapi`.
  */
-export type ThemeMode = NovasamaThemeMode;
+export type ThemeMode = HostThemeSubscribeItem;
 
-/** Light/dark variant of the active theme: `"Light" | "Dark"`. */
-export type ThemeVariant = ThemeMode["variant"];
+/** Light/dark variant of the active theme (`"Light" | "Dark"`) and the active theme name. Re-exported from `@parity/truapi`. */
+export type { ThemeName, ThemeVariant } from "@parity/truapi";
 
 /**
- * Active theme name: `{ tag: "Default" }`, or `{ tag: "Custom", value }`
- * carrying the custom theme's string id.
+ * Host theme provider handle. `subscribeTheme(callback)` receives a typed
+ * {@link ThemeMode} on every change and returns a {@link HostSubscription}.
  */
-export type ThemeName = ThemeMode["name"];
+export interface ThemeProvider {
+    subscribeTheme(callback: (theme: ThemeMode) => void): HostSubscription;
+}
+
+/** Build a {@link ThemeProvider} over a TruAPI client's `theme` domain. */
+function adaptThemeProvider(client: TrUApiClient): ThemeProvider {
+    return {
+        subscribeTheme(callback) {
+            return subscribeWithInterrupt(client.theme.subscribe(), callback);
+        },
+    };
+}
 
 /**
- * Get the host theme provider.
- *
- * Returns the theme-subscription handle exported by
- * `@novasamatech/host-api-wrapper`, or `null` if the package is unavailable
- * (running outside a host container or the optional peer dep isn't
- * installed).
- *
- * Implementation note: upstream `@novasamatech/host-api-wrapper` exports only
- * the `createThemeProvider` factory and no `themeProvider` singleton, so
- * this getter constructs a fresh instance on each call (unlike
- * {@link getPreimageManager} or {@link getHostLocalStorage}, which return
- * upstream singletons). The constructed provider is cheap to allocate; it
- * only opens a subscription when `subscribeTheme` is called.
+ * Get the host theme provider, backed by `truApi.theme.*`. Returns `null` when
+ * running outside a host container.
  *
  * @returns The theme provider, or `null` if unavailable.
  *
@@ -87,20 +65,14 @@ export type ThemeName = ThemeMode["name"];
  * ```
  */
 export async function getThemeProvider(): Promise<ThemeProvider | null> {
-    try {
-        const sdk = await import("@novasamatech/host-api-wrapper");
-        return sdk.createThemeProvider();
-    } catch (err) {
-        log.debug("getThemeProvider unavailable", err);
-        return null;
-    }
+    const client = await getClient();
+    return client ? adaptThemeProvider(client) : null;
 }
 
 if (import.meta.vitest) {
     const { test, expect } = import.meta.vitest;
 
-    test("getThemeProvider returns provider when SDK is available", async () => {
-        const provider = await getThemeProvider();
-        expect(provider === null || typeof provider === "object").toBe(true);
+    test("getThemeProvider returns null outside a container", async () => {
+        expect(await getThemeProvider()).toBeNull();
     });
 }

package/src/transport.ts

@@ -0,0 +1,71 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Access to the in-house TruAPI client (`@parity/truapi`) for the host package.
+ *
+ * Environment detection and the lazily-built, cached client come from
+ * `@parity/truapi/sandbox`; this module layers the product-sdk-specific glue on
+ * top — an async {@link getClient} accessor and {@link subscribeWithInterrupt},
+ * which adapts a truapi stream into the host's {@link HostSubscription} shape.
+ *
+ * @module
+ */
+
+import type { ObservableLike, TrUApiClient } from "@parity/truapi";
+import { getClientSync, isCorrectEnvironment } from "@parity/truapi/sandbox";
+
+import type { HostSubscription } from "./types.js";
+
+export { getClientSync, isCorrectEnvironment };
+
+/**
+ * Get the TruAPI client. Returns `null` outside a host container. Async wrapper
+ * over {@link getClientSync} for the host wrappers that already `await` it.
+ */
+export async function getClient(): Promise<TrUApiClient | null> {
+    return getClientSync();
+}
+
+/**
+ * Adapt a truapi `ObservableLike` stream into the host's callback-style
+ * {@link HostSubscription} (`unsubscribe` + `onInterrupt`). `onNext` fires for
+ * each item; the registered `onInterrupt` callback fires when the host ends the
+ * subscription server-side — which the generated client surfaces as either
+ * `complete` (a host interrupt frame) or `error` (transport close). Shared by
+ * the statement-store and preimage adapters, which both expose this shape.
+ */
+export function subscribeWithInterrupt<Item, Reason = never>(
+    observable: ObservableLike<Item, Reason>,
+    onNext: (item: Item) => void,
+): HostSubscription {
+    let interruptCallback: ((reason?: unknown) => void) | undefined;
+    const sub = observable.subscribe({
+        next: onNext,
+        error: (reason) => interruptCallback?.(reason),
+        complete: () => interruptCallback?.(),
+    });
+    return {
+        unsubscribe: () => sub.unsubscribe(),
+        onInterrupt: (callback) => {
+            interruptCallback = callback;
+            return () => {
+                if (interruptCallback === callback) interruptCallback = undefined;
+            };
+        },
+    };
+}
+
+if (import.meta.vitest) {
+    const { test, expect } = import.meta.vitest;
+
+    // Environment detection and client building are covered by `@parity/truapi`'s
+    // own sandbox tests; here we only assert the local glue degrades outside a
+    // host container.
+    test("getClientSync returns null outside a container", () => {
+        expect(getClientSync()).toBeNull();
+    });
+
+    test("getClient resolves null outside a container", async () => {
+        expect(await getClient()).toBeNull();
+    });
+}